{"matchId":"54455592","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-10-01T03:47:38Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x6080604052348015600e575f5ffd5b506117fc8061001c5f395ff3fe60806040526004361061005b575f3560e01c8063324012e211610041578063324012e2146100a057806370a08231146100b3578063b18248d5146100d2575f5ffd5b8063197aa51e146100665780631bb1a5301461007b575f5ffd5b3661006257005b5f5ffd5b610079610074366004611326565b6100e5565b005b61008e610089366004611436565b61011e565b60405190815260200160405180910390f35b6100796100ae3660046114cf565b6103ca565b3480156100be575f5ffd5b506100796100cd36600461159d565b61042f565b6100796100e03660046115b6565b610437565b6100ef8282610622565b60405183907fe2a752598b97815acff854b1d0b6d5c7f33b848bcbb541df9b76038287282467905f90a2505050565b5f8060208701351580159061013557506001891615155b905060028916151561016761015060408b0160208c0161159d565b61015d60208c018c61159d565b8b60400135610992565b604089013560208901351580159061017d575082155b156101b3576020808a0135906101b09061019d9060408e01908e0161159d565b6101aa60208d018d61159d565b83610ab2565b90035b5f6101c460408a0160208b0161159d565b6001600160a01b031614158015610207575073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6101fb60408c0160208d0161159d565b6001600160a01b031614155b80156102c5575061021e60408b0160208c0161159d565b6001600160a01b031663dd62ed3e3061023d60408c0160208d0161159d565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b1681526001600160a01b03928316600482015291166024820152604401602060405180830381865afa15801561029e573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102c29190611635565b81115b156102f4576102f46102dd60408c0160208d0161159d565b6102ed60408b0160208c0161159d565b5f19610aec565b505f826103015784610303565b305b90506103128888888585610b88565b93508760800135841015610352576040517f3453a1e700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b821561039157602089013561037061019d60608b0160408c0161159d565b938490039361038f61038860608b0160408c0161159d565b8787610ab2565b505b6040518c907fe2a752598b97815acff854b1d0b6d5c7f33b848bcbb541df9b76038287282467905f90a250505098975050505050505050565b5f6103d98a8a8a8a8a8a610c31565b90506103f86103ee6060890160408a0161159d565b828c878787610e81565b6040518b907fe2a752598b97815acff854b1d0b6d5c7f33b848bcbb541df9b76038287282467905f90a25050505050505050505050565b5f5f5360015ff35b61046161044a604087016020880161159d565b610457602088018861159d565b8760400135610992565b6020840135801561048c5761048c61047f604088016020890161159d565b6101aa602088018861159d565b604080870135829003905f906104a79087016020880161159d565b6001600160a01b0316141580156104ea575073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee6104de6040890160208a0161159d565b6001600160a01b031614155b80156105a85750610501604088016020890161159d565b6001600160a01b031663dd62ed3e306105206040890160208a0161159d565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b1681526001600160a01b03928316600482015291166024820152604401602060405180830381865afa158015610581573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105a59190611635565b81115b156105d0576105d06105c06040890160208a0161159d565b6102ed604088016020890161159d565b6105ed6105e0602087018761159d565b866040013586865f61102c565b5060405188907fe2a752598b97815acff854b1d0b6d5c7f33b848bcbb541df9b76038287282467905f90a25050505050505050565b805f8167ffffffffffffffff81111561063d5761063d61164c565b60405190808252806020026020018201604052801561067057816020015b606081526020019060019003908161065b5790505b5090505f5b8281101561098b573685858381811061069057610690611660565b90506020028101906106a29190611674565b90505f6106b260208301836116b0565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201829052509394506106f59250505060408401846116f3565b905090505f5b81811015610842575f61071160408601866116f3565b8381811061072157610721611660565b602002919091013591505067ffffffffffffffff811686811061077f576040517f8ac3a5c300000000000000000000000000000000000000000000000000000000815260048101889052602481018290526044015b60405180910390fd5b875167ffffffffffffffff604084901c811691608085901c9091169060c085901c905f908c90869081106107b5576107b5611660565b60200260200101519050805182856107cd919061174d565b11806107e2575088516107e0838561174d565b115b15610823576040517fba5d879f000000000000000000000000000000000000000000000000000000008152600481018c905260248101889052604401610776565b818460208301018460208c01015e8660010196505050505050506106fb565b505f833561ff008116151560ff8216601083901c60018203610870575f5f885160208a01845afa94506108f3565b600282036108e4576020875110156108b7576040517f4208b27c000000000000000000000000000000000000000000000000000000008152600481018a9052602401610776565b5f5f602089516108c79190611760565b9050602089015191505f5f8260408c0185875af1965050506108f3565b5f5f885160208a015f855af194505b8415806108fd5750825b15610978576040513d808252805f602084013e603f90820101601f1916604052856109585789816040517f5c0dee5d000000000000000000000000000000000000000000000000000000008152600401610776929190611773565b808b8b8151811061096b5761096b611660565b6020026020010181905250505b8860010198505050505050505050610675565b5050505050565b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeed196001600160a01b038416016109f657803410156109f1576040517f78f38f7600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b505050565b816001600160a01b0316610a08611091565b6001600160a01b031614610a48576040517f85132e0f00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f7350c4e75a512f2a14a7b304787adf79c4531a590990506040518281608001523081606001528360601b81604c01528460601b81602c01526f15dacbea00000000000000000000000081600c01525f5f608483601c015f865af161098b576040513d5f823e3d81fd5b73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeed196001600160a01b03841601610ae1576109f182826110e5565b6109f1838383611173565b81601452806034526f095ea7b30000000000000000000000005f5260205f604460105f875af18060015f511416610b7e57803d853b151710610b7e575f6034526f095ea7b30000000000000000000000005f525f38604460105f885af1508160345260205f604460105f885af190508060015f511416610b7e57803d853b151710610b7e57633e3f8f735f526004601cfd5b505f603452505050565b5f8215610bf5575f610ba9610ba36060890160408a0161159d565b846111bc565b9050610bc8610bbb602089018961159d565b886060013588885f61102c565b5080610be3610bdd60608a0160408b0161159d565b856111bc565b610bed9190611760565b915050610c28565b5f610c14610c06602089018961159d565b88606001358888600161102c565b9050610c24818860a00135611206565b9150505b95945050505050565b5f610c5c610c45604088016020890161159d565b610c52602089018961159d565b8860400135610992565b5f60208601358015801590610c7357506001891615155b915060408801358115801590610c87575082155b15610cb657610cb2610c9f60408b0160208c0161159d565b610cac60208b018b61159d565b84610ab2565b8190035b5f610cc76040890160208a0161159d565b6001600160a01b031614158015610d0a575073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee610cfe60408b0160208c0161159d565b6001600160a01b031614155b8015610dc85750610d2160408a0160208b0161159d565b6001600160a01b031663dd62ed3e30610d4060408b0160208c0161159d565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b1681526001600160a01b03928316600482015291166024820152604401602060405180830381865afa158015610da1573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610dc59190611635565b81115b15610df057610df0610de060408b0160208c0161159d565b6102ed60408a0160208b0161159d565b5050600288161515610e058686868430610b88565b92508560800135831015610e45576040517f3453a1e700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8115610e75576020870135610e70610e636060890160408a0161159d565b6101aa60208b018b61159d565b909203915b50509695505050505050565b5f82828080601f0160208091040260200160405190810160405280939291908181526020018383808284375f920191909152509293505050506008851615610ed957601085901c61ffff16610ed7828289611269565b505b5f610eea604086016020870161159d565b6001600160a01b031614158015610f1e57506001600160a01b03871673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee14155b8015610fcd57506001600160a01b03871663dd62ed3e30610f45604088016020890161159d565b6040517fffffffff0000000000000000000000000000000000000000000000000000000060e085901b1681526001600160a01b03928316600482015291166024820152604401602060405180830381865afa158015610fa6573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610fca9190611635565b86115b15610fe657610fe6876102ed604087016020880161159d565b5f600486165f03610ffb578460400135611009565b61100960408601358861174d565b905061102261101b602087018761159d565b82846112b6565b5050505050505050565b60605f60405184868237808501601f01601f19166040525f8086838a8c5af19150508015806110585750825b15611087573d6040519250808352805f602085013e603f90830101601f19166040528061108757815160208301fd5b5095945050505050565b337fffffffffffffffffffffffffaf3b18a5aed0d5eb584cfb878520863bace5a6f781016110e257507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec36013560601c5b90565b5f826001600160a01b031682616978906040515f60405180830381858888f193505050503d805f8114611133576040519150601f19603f3d011682016040523d82523d5f602084013e611138565b606091505b50509050806109f1576040517f90b8ec1800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b81601452806034526fa9059cbb0000000000000000000000005f5260205f604460105f875af18060015f511416610b7e57803d853b151710610b7e576390b8ec185f526004601cfd5b5f73eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeed196001600160a01b038416016111f357506001600160a01b03811631611200565b6111fd83836112f3565b90505b92915050565b5f806112138360206117af565b845190915061122382602061174d565b111561125b576040517f6ef2ffe200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b929092016020015192915050565b825161127683602061174d565b11156112ae576040517f7a353f8a00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b910160200152565b5f5f5f83516020850186885af19050806112ed576040513d808252805f602084013e603f90820101601f1916604052805160208201fd5b50505050565b5f816014526f70a082310000000000000000000000005f5260208060246010865afa601f3d111660205102905092915050565b5f5f5f60408486031215611338575f5ffd5b83359250602084013567ffffffffffffffff811115611355575f5ffd5b8401601f81018613611365575f5ffd5b803567ffffffffffffffff81111561137b575f5ffd5b8660208260051b840101111561138f575f5ffd5b939660209190910195509293505050565b5f606082840312156113b0575f5ffd5b50919050565b5f604082840312156113b0575f5ffd5b5f60c082840312156113b0575f5ffd5b5f5f83601f8401126113e6575f5ffd5b50813567ffffffffffffffff8111156113fd575f5ffd5b602083019150836020828501011115611414575f5ffd5b9250929050565b80356001600160a01b0381168114611431575f5ffd5b919050565b5f5f5f5f5f5f5f5f6101e0898b03121561144e575f5ffd5b88359750602089013596506114668a60408b016113a0565b95506114758a60a08b016113b6565b94506114848a60e08b016113c6565b93506101a089013567ffffffffffffffff8111156114a0575f5ffd5b6114ac8b828c016113d6565b90945092506114c090506101c08a0161141b565b90509295985092959890939650565b5f5f5f5f5f5f5f5f5f5f6102408b8d0312156114e9575f5ffd5b8a35995060208b013598506115018c60408d016113a0565b97506115108c60a08d016113b6565b965061151f8c60e08d016113c6565b95506101a08b013567ffffffffffffffff81111561153b575f5ffd5b6115478d828e016113d6565b909650945061155c90508c6101c08d016113a0565b92506102208b013567ffffffffffffffff811115611578575f5ffd5b6115848d828e016113d6565b915080935050809150509295989b9194979a5092959850565b5f602082840312156115ad575f5ffd5b6111fd8261141b565b5f5f5f5f5f5f61014087890312156115cc575f5ffd5b863595506115dd88602089016113a0565b94506115ec88608089016113b6565b93506115fb8860c089016113a0565b925061012087013567ffffffffffffffff811115611617575f5ffd5b61162389828a016113d6565b979a9699509497509295939492505050565b5f60208284031215611645575f5ffd5b5051919050565b634e487b7160e01b5f52604160045260245ffd5b634e487b7160e01b5f52603260045260245ffd5b5f82357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa18336030181126116a6575f5ffd5b9190910192915050565b5f5f8335601e198436030181126116c5575f5ffd5b83018035915067ffffffffffffffff8211156116df575f5ffd5b602001915036819003821315611414575f5ffd5b5f5f8335601e19843603018112611708575f5ffd5b83018035915067ffffffffffffffff821115611722575f5ffd5b6020019150600581901b3603821315611414575f5ffd5b634e487b7160e01b5f52601160045260245ffd5b8082018082111561120057611200611739565b8181038181111561120057611200611739565b828152604060208201525f82518060408401528060208501606085015e5f606082850101526060601f19601f8301168401019150509392505050565b80820281158282048414176112005761120061173956fea264697066735822122067fd313fab5c363fc10008d8b7957b153905ffeaba0b005e68db088c53a3ab8b64736f6c63430008220033","sourceMap":"902:35395:1:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122067fd313fab5c363fc10008d8b7957b153905ffeaba0b005e68db088c53a3ab8b64736f6c63430008220033","offset":6115}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"902:35395:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17231:166;;;;;;:::i;:::-;;:::i;:::-;;10577:2577;;;;;;:::i;:::-;;:::i;:::-;;;3059:25:7;;;3047:2;3032:18;10577:2577:1;;;;;;;13992:605;;;;;;:::i;:::-;;:::i;2304:157:2:-;;;;;;;;;;-1:-1:-1;2304:157:2;;;;;:::i;:::-;;:::i;15597:1319:1:-;;;;;;:::i;:::-;;:::i;17231:166::-;17326:24;17342:7;;17326:15;:24::i;:::-;17366;;17382:7;;17366:24;;;;;17231:166;;;:::o;10577:2577::-;10834:19;;10903:10;;;;:15;;;;:58;;-1:-1:-1;7335:4:1;10924:30;;10923:37;;10903:58;10888:73;-1:-1:-1;7514:4:1;10993:29;;10992:36;;11110:62;11124:16;;;;;;;;:::i;:::-;11142:10;;;;:5;:10;:::i;:::-;11154:5;:17;;;11110:13;:62::i;:::-;11243:17;;;;11278:10;;;;:15;;;;:27;;;11298:7;11297:8;11278:27;11274:267;;;11345:10;;;;;;11373:63;;11394:16;;;;;;;;;:::i;:::-;11412:12;;;;:3;:12;:::i;:::-;11426:9;11373:20;:63::i;:::-;11486:22;;11274:267;11684:1;11648:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11648:38:1;;;:94;;;;-1:-1:-1;682:42:6;11690:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11690:52:1;;;11648:94;:253;;;;-1:-1:-1;11833:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11826:34:1;;11869:4;11876:24;;;;;;;;:::i;:::-;11826:75;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;11826:75:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;11826:75:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11814:9;:87;11648:253;11586:503;;;11975:99;12012:16;;;;;;;;:::i;:::-;12030:24;;;;;;;;:::i;:::-;-1:-1:-1;;11975:36:1;:99::i;:::-;11040:1059;12344:22;12369:7;:34;;12395:8;12369:34;;;12387:4;12369:34;12344:59;;12452:63;12462:8;12472:12;;12486;12500:14;12452:9;:63::i;:::-;12438:77;;12543:8;:18;;;12529:11;:32;12525:69;;;12570:24;;;;;;;;;;;;;;12525:69;12609:7;12605:393;;;12689:10;;;;12713:67;12734:20;;;;;;;;:::i;12713:67::-;12822:24;;;;;12922:65;12943:20;;;;;;;;:::i;:::-;12965:8;12975:11;12922:20;:65::i;:::-;12618:380;12605:393;13123:24;;13139:7;;13123:24;;;;;10855:2299;;;10577:2577;;;;;;;;;;:::o;13992:605::-;14350:19;14372:60;14390:5;14397;14404:3;14409:8;14419:12;;14372:17;:60::i;:::-;14350:82;-1:-1:-1;14469:81:1;14481:20;;;;;;;;:::i;:::-;14503:11;14516:5;14523:10;14535:14;;14469:11;:81::i;:::-;14566:24;;14582:7;;14566:24;;;;;14302:295;13992:605;;;;;;;;;;:::o;2304:157:2:-;2409:4;;2395:19;2440:4;2409;2427:18;15597:1319:1;15866:62;15880:16;;;;;;;;:::i;:::-;15898:10;;;;:5;:10;:::i;:::-;15910:5;:17;;;15866:13;:62::i;:::-;15993:10;;;;16017:14;;16013:108;;16047:63;16068:16;;;;;;;;:::i;:::-;16086:12;;;;:3;:12;:::i;16047:63::-;16194:17;;;;;:29;;;;16131:17;;16333:26;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16333:40:1;;;:96;;;;-1:-1:-1;682:42:6;16377:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16377:52:1;;;16333:96;:249;;;;-1:-1:-1;16512:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16505:34:1;;16548:4;16555:26;;;;;;;;:::i;:::-;16505:77;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;16505:77:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;16505:77:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16493:9;:89;16333:249;16278:478;;;16644:101;16681:16;;;;;;;;:::i;:::-;16699:26;;;;;;;;:::i;16644:101::-;16792:77;16810:17;;;;:10;:17;:::i;:::-;16829:10;:16;;;16847:14;;16863:5;16792:17;:77::i;:::-;-1:-1:-1;16885:24:1;;16901:7;;16885:24;;;;;15804:1112;;15597:1319;;;;;;:::o;22707:4547::-;22802:7;22778:21;22802:7;22851:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22826:51;;22893:9;22888:4360;22908:13;22904:1;:17;22888:4360;;;22938:22;22963:7;;22971:1;22963:10;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;22938:35;-1:-1:-1;22987:21:1;23011:11;;;;22938:35;23011:11;:::i;:::-;22987:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22987:35:1;;-1:-1:-1;23131:14:1;;-1:-1:-1;;;23131:14:1;;;;;:::i;:::-;:21;;23107:45;;23171:9;23166:1308;23186:13;23182:1;:17;23166:1308;;;23220:18;23241:14;;;;:6;:14;:::i;:::-;23256:1;23241:17;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;23276:46:1;;;23413:22;;;23409:69;;23444:34;;;;;;;;8342:25:7;;;8383:18;;;8376:34;;;8315:18;;23444:34:1;;;;;;;;23409:69;23892:26;;23497:44;23538:2;23524:16;;;23497:44;;;23652:3;23638:17;;;23611:45;;;;23758:3;23744:17;;;;23497;;23892:7;;23900:17;;23892:26;;;;;;:::i;:::-;;;;;;;23870:48;;23961:6;:13;23952:6;23940:9;:18;;;;:::i;:::-;:34;:74;;;-1:-1:-1;23999:15:1;;23978:18;23990:6;23978:9;:18;:::i;:::-;:36;23940:74;23936:151;;;24045:23;;;;;;;;8342:25:7;;;8383:18;;;8376:34;;;8315:18;;24045:23:1;8168:248:7;23936:151:1;24363:6;24351:9;24344:4;24336:6;24332:17;24328:33;24316:9;24309:4;24299:8;24295:19;24291:35;24285:85;24438:3;;;;;23202:1272;;;;;;23166:1308;;;-1:-1:-1;24520:12:1;24567:17;;24631:6;24618:19;;24617:26;;24725:4;24712:17;;24822:2;24808:16;;;24893:19;24873:8;:40;24869:1277;;25131:1;25128;25117:8;25111:15;25104:4;25094:8;25090:19;25082:6;25075:5;25064:69;25053:80;;24869:1277;;;25195:25;25175:8;:46;25171:975;;25263:2;25245:8;:15;:20;25241:54;;;25274:21;;;;;;;;3059:25:7;;;3032:18;;25274:21:1;2913:177:7;25241:54:1;25313:17;25348:21;25390:2;25372:8;:15;:20;;;;:::i;:::-;25348:44;;25586:4;25576:8;25572:19;25566:26;25553:39;;25780:1;25777;25762:13;25755:4;25745:8;25741:19;25730:9;25722:6;25715:5;25710:72;25699:83;;25435:416;;25171:975;;;26112:1;26109;26098:8;26092:15;26085:4;26075:8;26071:19;26068:1;26060:6;26053:5;26048:66;26037:77;;25171:975;26260:7;26259:8;:23;;;;26271:11;26259:23;26255:924;;;26504:4;26498:11;26454:16;26530:27;;;26454:16;26652:1;26645:4;26636:14;;26621:49;26740:46;26744:35;;;26740:46;-1:-1:-1;;26736:62:1;26730:4;26723:76;27021:7;27016:39;;27048:1;27051:3;27037:18;;;;;;;;;;;;:::i;27016:39::-;27161:3;27148:7;27156:1;27148:10;;;;;;;;:::i;:::-;;;;;;:16;;;;26284:895;26255:924;27220:3;;;;;22924:4324;;;;;;;;22888:4360;;;;22768:4486;;22707:4547;;:::o;27998:2943::-;-1:-1:-1;;;;;;;28134:41:1;;;28130:177;;28207:6;28195:9;:18;28191:86;;;28240:22;;;;;;;;;;;;;;28191:86;27998:2943;;;:::o;28130:177::-;28369:4;-1:-1:-1;;;;;28353:20:1;:12;:10;:12::i;:::-;-1:-1:-1;;;;;28353:20:1;;28349:54;;28382:21;;;;;;;;;;;;;;28349:54;28461:23;260:42:3;28461:51:1;;29622:4;29616:11;29663:6;29657:3;29651:4;29647:14;29640:30;29761:9;29755:3;29749:4;29745:14;29738:33;29912:4;29906;29902:15;29896:3;29890:4;29886:14;29879:39;30314:5;30308:4;30304:16;30298:3;30292:4;30288:14;30281:40;30453:34;30447:3;30441:4;30437:14;30430:58;30686:4;30680;30674;30668:3;30662:4;30658:14;30652:4;30635:15;30628:5;30623:68;30613:312;;30804:4;30798:11;30850:16;30844:4;30841:1;30826:41;30894:16;30891:1;30884:27;1309:272:6;-1:-1:-1;;;;;;;1400:29:6;;;1396:179;;1445:34;1461:9;1472:6;1445:15;:34::i;1396:179::-;1510:54;1539:5;1546:9;1557:6;1510:28;:54::i;20166:1707:0:-;20337:2;20331:4;20324:16;20394:6;20388:4;20381:20;20459:34;20453:4;20446:48;20653:4;20647;20641;20635;20632:1;20625:5;20618;20613:45;20705:7;20701:1;20694:4;20688:11;20685:18;20681:32;20671:1089;;20796:7;20777:16;20768:5;20756:18;20749:26;20746:48;20743:61;20733:1013;;20841:1;20835:4;20828:15;20906:34;20900:4;20893:48;21043:4;21031:10;21025:4;21019;21016:1;21009:5;21002;20997:51;20993:56;21106:6;21100:4;21093:20;21289:4;21283;21277;21271;21268:1;21261:5;21254;21249:45;21238:56;;21349:7;21345:1;21338:4;21332:11;21329:18;21325:32;21315:413;;21547:7;21528:16;21519:5;21507:18;21500:26;21497:48;21494:61;21484:222;;21600:10;21594:4;21587:24;21675:4;21669;21662:18;21484:222;20671:1089;21786:1;21780:4;21773:15;20166:1707;;;:::o;31810:846:1:-;31985:19;32020:12;32016:634;;;32136:14;32153:59;32175:20;;;;;;;;:::i;:::-;32197:14;32153:21;:59::i;:::-;32136:76;-1:-1:-1;32226:71:1;32244:15;;;;:8;:15;:::i;:::-;32261:8;:14;;;32277:12;;32291:5;32226:17;:71::i;:::-;-1:-1:-1;32387:6:1;32325:59;32347:20;;;;;;;;:::i;:::-;32369:14;32325:21;:59::i;:::-;:68;;;;:::i;:::-;32311:82;;32034:370;32016:634;;;32469:16;32488:70;32506:15;;;;:8;:15;:::i;:::-;32523:8;:14;;;32539:12;;32553:4;32488:17;:70::i;:::-;32469:89;;32586:53;32604:3;32609:8;:29;;;32586:17;:53::i;:::-;32572:67;;32410:240;32016:634;31810:846;;;;;;;:::o;18355:2055::-;18566:19;18649:62;18663:16;;;;;;;;:::i;:::-;18681:10;;;;:5;:10;:::i;:::-;18693:5;:17;;;18649:13;:62::i;:::-;18722:12;18814:10;;;;18848:14;;;;;:57;;-1:-1:-1;7335:4:1;18868:30;;18867:37;;18848:57;18838:67;-1:-1:-1;18939:17:1;;;;18975:14;;;;;:26;;;18994:7;18993:8;18975:26;18971:218;;;19021:63;19042:16;;;;;;;;:::i;:::-;19060:12;;;;:3;:12;:::i;:::-;19074:9;19021:20;:63::i;:::-;19134:22;;;18971:218;19337:1;19301:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19301:38:1;;;:94;;;;-1:-1:-1;682:42:6;19343:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19343:52:1;;;19301:94;:253;;;;-1:-1:-1;19486:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19479:34:1;;19522:4;19529:24;;;;;;;;:::i;:::-;19479:75;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;19479:75:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;19479:75:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19467:9;:87;19301:253;19239:503;;;19628:99;19665:16;;;;;;;;:::i;:::-;19683:24;;;;;;;;:::i;19628:99::-;-1:-1:-1;;7514:4:1;19930:29;;19929:36;;19990:62;20000:8;20010:12;;19929:36;20046:4;19990:9;:62::i;:::-;19976:76;;20080:8;:18;;;20066:11;:32;20062:69;;;20107:24;;;;;;;;;;;;;;20062:69;20179:7;20175:229;;;20222:10;;;;20246:67;20267:20;;;;;;;;:::i;:::-;20289:12;;;;:3;:12;:::i;20246:67::-;20355:24;;;;20175:229;18587:1823;;18355:2055;;;;;;;;:::o;21007:1330::-;21202:28;21233:14;;21202:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21202:45:1;;-1:-1:-1;;;;7906:4:1;21320:44;;:49;21316:264;;8039:2;21404:37;;;8183:6;21404:67;21485:84;21518:15;21404:67;21561:6;21485:25;:84::i;:::-;21371:209;21316:264;21716:1;21678:26;;;;;;;;:::i;:::-;-1:-1:-1;;;;;21678:40:1;;;:85;;;;-1:-1:-1;;;;;;21722:41:1;;682:42:6;21722:41:1;;21678:85;:224;;;;-1:-1:-1;;;;;;21836:23:1;;;21868:4;21875:26;;;;;;;;:::i;:::-;21836:66;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;21836:66:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;21836:66:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21827:6;:75;21678:224;21624:441;;;21964:90;22001:5;22008:26;;;;;;;;:::i;21964:90::-;22118:19;7722:4;22142:5;:34;22181:1;22141:41;22140:90;;22214:10;:16;;;22140:90;;;22186:25;22195:16;;;;22186:6;:25;:::i;:::-;22118:112;-1:-1:-1;22272:58:1;22282:17;;;;:10;:17;:::i;:::-;22301:11;22314:15;22272:9;:58::i;:::-;21192:1145;;21007:1330;;;;;;:::o;34286:1320::-;34417:16;34449:12;34527:4;34521:11;34576;34563;34558:3;34545:43;34693:21;;;34727:4;34689:32;-1:-1:-1;;34685:48:1;34679:4;34672:62;34855:1;;34702:11;34697:3;34827:5;34819:6;34812:5;34807:50;34796:61;;;34882:7;34881:8;:23;;;;34893:11;34881:23;34877:723;;;35032:16;35078:4;35072:11;35065:18;;35112:14;35107:3;35100:27;35221:14;35218:1;35211:4;35206:3;35202:14;35187:49;35302:46;35306:35;;;35302:46;-1:-1:-1;;35298:62:1;35292:4;35285:76;35414:7;35409:181;;35517:3;35511:10;35504:4;35499:3;35495:14;35488:34;35409:181;34439:1167;34286:1320;;;;;;;:::o;984:445:2:-;1072:10;1096:35;;;1092:331;;-1:-1:-1;1372:25:2;1376:14;1372:25;1359:39;1353:4;1349:50;1092:331;984:445;:::o;1587:220:6:-;1666:12;1683:9;-1:-1:-1;;;;;1683:14:6;1705:6;1718;1683:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1665:64;;;1744:7;1739:62;;1774:16;;;;;;;;;;;;;;16340:887:0;16503:2;16497:4;16490:16;16560:6;16554:4;16547:20;16625:34;16619:4;16612:48;16821:4;16815;16809;16803;16800:1;16793:5;16786;16781:45;16873:7;16869:1;16862:4;16856:11;16853:18;16849:32;16839:275;;16964:7;16945:16;16936:5;16924:18;16917:26;16914:48;16911:61;16901:199;;17009:10;17003:4;16996:24;17077:4;17071;17064:18;732:265:6;803:15;-1:-1:-1;;;;;;;834:29:6;;;830:161;;-1:-1:-1;;;;;;889:12:6;;;830:161;;;942:38;968:5;975:4;942:25;:38::i;:::-;932:48;;830:161;732:265;;;;:::o;35913:382:1:-;36001:12;;36042:15;:10;36055:2;36042:15;:::i;:::-;36085:10;;36025:32;;-1:-1:-1;36071:11:1;36025:32;36080:2;36071:11;:::i;:::-;:24;36067:60;;;36104:23;;;;;;;;;;;;;;36067:60;36251:27;;;;36264:4;36251:27;36245:34;;35913:382;-1:-1:-1;;35913:382:1:o;561:423:5:-;732:11;;716:13;:8;727:2;716:13;:::i;:::-;:27;712:92;;;766:27;;;;;;;;;;;;;;712:92;931:30;;945:4;931:30;924:44;561:423::o;32881:885:1:-;32969:12;33101:1;33098;33091:4;33085:11;33078:4;33072;33068:15;33061:5;33053:6;33046:5;33041:62;33030:73;;33128:7;33123:637;;33339:4;33333:11;33293:16;33361:27;;;33293:16;33479:1;33472:4;33463:14;;33448:49;33563:46;33567:35;;;33563:46;-1:-1:-1;;33559:62:1;33553:4;33546:76;33683:10;;33580:4;33571:14;;33660:34;33123:637;32959:807;32881:885;;;:::o;22000:739:0:-;22074:14;22179:7;22173:4;22166:21;22246:34;22240:4;22233:48;22678:4;22672;22666;22660;22653:5;22646;22635:48;22573:4;22555:16;22552:26;22463:242;22436:4;22430:11;22345:378;22319:404;;22000:739;;;;:::o;14:749:7:-;134:6;142;150;203:2;191:9;182:7;178:23;174:32;171:52;;;219:1;216;209:12;171:52;264:23;;;-1:-1:-1;362:2:7;347:18;;334:32;389:18;378:30;;375:50;;;421:1;418;411:12;375:50;444:22;;497:4;489:13;;485:27;-1:-1:-1;475:55:7;;526:1;523;516:12;475:55;566:2;553:16;592:18;584:6;581:30;578:50;;;624:1;621;614:12;578:50;677:7;672:2;662:6;659:1;655:14;651:2;647:23;643:32;640:45;637:65;;;698:1;695;688:12;637:65;14:749;;729:2;721:11;;;;;-1:-1:-1;751:6:7;;-1:-1:-1;;;14:749:7:o;768:157::-;830:5;875:2;866:6;861:3;857:16;853:25;850:45;;;891:1;888;881:12;850:45;-1:-1:-1;913:6:7;768:157;-1:-1:-1;768:157:7:o;930:155::-;990:5;1035:2;1026:6;1021:3;1017:16;1013:25;1010:45;;;1051:1;1048;1041:12;1090:157;1151:5;1196:3;1187:6;1182:3;1178:16;1174:26;1171:46;;;1213:1;1210;1203:12;1252:347;1303:8;1313:6;1367:3;1360:4;1352:6;1348:17;1344:27;1334:55;;1385:1;1382;1375:12;1334:55;-1:-1:-1;1408:20:7;;1451:18;1440:30;;1437:50;;;1483:1;1480;1473:12;1437:50;1520:4;1512:6;1508:17;1496:29;;1572:3;1565:4;1556:6;1548;1544:19;1540:30;1537:39;1534:59;;;1589:1;1586;1579:12;1534:59;1252:347;;;;;:::o;1604:196::-;1672:20;;-1:-1:-1;;;;;1721:54:7;;1711:65;;1701:93;;1790:1;1787;1780:12;1701:93;1604:196;;;:::o;1805:1103::-;2010:6;2018;2026;2034;2042;2050;2058;2066;2119:3;2107:9;2098:7;2094:23;2090:33;2087:53;;;2136:1;2133;2126:12;2087:53;2181:23;;;-1:-1:-1;2301:2:7;2286:18;;2273:32;;-1:-1:-1;2350:65:7;2407:7;2402:2;2387:18;;2350:65;:::i;:::-;2340:75;;2434:64;2490:7;2484:3;2473:9;2469:19;2434:64;:::i;:::-;2424:74;;2517:65;2574:7;2568:3;2557:9;2553:19;2517:65;:::i;:::-;2507:75;;2633:3;2622:9;2618:19;2605:33;2661:18;2653:6;2650:30;2647:50;;;2693:1;2690;2683:12;2647:50;2732:58;2782:7;2773:6;2762:9;2758:22;2732:58;:::i;:::-;2809:8;;-1:-1:-1;2706:84:7;-1:-1:-1;2863:39:7;;-1:-1:-1;2897:3:7;2882:19;;2863:39;:::i;:::-;2853:49;;1805:1103;;;;;;;;;;;:::o;3095:1463::-;3349:6;3357;3365;3373;3381;3389;3397;3405;3413;3421;3474:3;3462:9;3453:7;3449:23;3445:33;3442:53;;;3491:1;3488;3481:12;3442:53;3536:23;;;-1:-1:-1;3656:2:7;3641:18;;3628:32;;-1:-1:-1;3705:65:7;3762:7;3757:2;3742:18;;3705:65;:::i;:::-;3695:75;;3789:64;3845:7;3839:3;3828:9;3824:19;3789:64;:::i;:::-;3779:74;;3872:65;3929:7;3923:3;3912:9;3908:19;3872:65;:::i;:::-;3862:75;;3988:3;3977:9;3973:19;3960:33;4016:18;4008:6;4005:30;4002:50;;;4048:1;4045;4038:12;4002:50;4087:58;4137:7;4128:6;4117:9;4113:22;4087:58;:::i;:::-;4164:8;;-1:-1:-1;4061:84:7;-1:-1:-1;4218:66:7;;-1:-1:-1;4276:7:7;4270:3;4255:19;;4218:66;:::i;:::-;4208:76;;4337:3;4326:9;4322:19;4309:33;4367:18;4357:8;4354:32;4351:52;;;4399:1;4396;4389:12;4351:52;4438:60;4490:7;4479:8;4468:9;4464:24;4438:60;:::i;:::-;4412:86;;4517:8;4507:18;;;4544:8;4534:18;;;3095:1463;;;;;;;;;;;;;:::o;4563:186::-;4622:6;4675:2;4663:9;4654:7;4650:23;4646:32;4643:52;;;4691:1;4688;4681:12;4643:52;4714:29;4733:9;4714:29;:::i;4754:911::-;4943:6;4951;4959;4967;4975;4983;5036:3;5024:9;5015:7;5011:23;5007:33;5004:53;;;5053:1;5050;5043:12;5004:53;5098:23;;;-1:-1:-1;5164:65:7;5221:7;5216:2;5201:18;;5164:65;:::i;:::-;5154:75;;5248:64;5304:7;5298:3;5287:9;5283:19;5248:64;:::i;:::-;5238:74;;5331:66;5389:7;5383:3;5372:9;5368:19;5331:66;:::i;:::-;5321:76;;5448:3;5437:9;5433:19;5420:33;5476:18;5468:6;5465:30;5462:50;;;5508:1;5505;5498:12;5462:50;5547:58;5597:7;5588:6;5577:9;5573:22;5547:58;:::i;:::-;4754:911;;;;-1:-1:-1;4754:911:7;;-1:-1:-1;4754:911:7;;5624:8;;4754:911;-1:-1:-1;;;4754:911:7:o;6021:184::-;6091:6;6144:2;6132:9;6123:7;6119:23;6115:32;6112:52;;;6160:1;6157;6150:12;6112:52;-1:-1:-1;6183:16:7;;6021:184;-1:-1:-1;6021:184:7:o;6210:::-;-1:-1:-1;;;6259:1:7;6252:88;6359:4;6356:1;6349:15;6383:4;6380:1;6373:15;6399:184;-1:-1:-1;;;6448:1:7;6441:88;6548:4;6545:1;6538:15;6572:4;6569:1;6562:15;6588:381;6679:4;6737:11;6724:25;6827:66;6816:8;6800:14;6796:29;6792:102;6772:18;6768:127;6758:155;;6909:1;6906;6899:12;6758:155;6930:33;;;;;6588:381;-1:-1:-1;;6588:381:7:o;6974:580::-;7051:4;7057:6;7117:11;7104:25;-1:-1:-1;;7196:8:7;7180:14;7176:29;7172:102;7152:18;7148:127;7138:155;;7289:1;7286;7279:12;7138:155;7316:33;;7368:20;;;-1:-1:-1;7411:18:7;7400:30;;7397:50;;;7443:1;7440;7433:12;7397:50;7476:4;7464:17;;-1:-1:-1;7507:14:7;7503:27;;;7493:38;;7490:58;;;7544:1;7541;7534:12;7559:604;7652:4;7658:6;7718:11;7705:25;-1:-1:-1;;7797:8:7;7781:14;7777:29;7773:102;7753:18;7749:127;7739:155;;7890:1;7887;7880:12;7739:155;7917:33;;7969:20;;;-1:-1:-1;8012:18:7;8001:30;;7998:50;;;8044:1;8041;8034:12;7998:50;8077:4;8065:17;;-1:-1:-1;8128:1:7;8124:14;;;8108;8104:35;8094:46;;8091:66;;;8153:1;8150;8143:12;8421:184;-1:-1:-1;;;8470:1:7;8463:88;8570:4;8567:1;8560:15;8594:4;8591:1;8584:15;8610:125;8675:9;;;8696:10;;;8693:36;;;8709:18;;:::i;8929:128::-;8996:9;;;9017:11;;;9014:37;;;9031:18;;:::i;9062:546::-;9237:6;9226:9;9219:25;9280:2;9275;9264:9;9260:18;9253:30;9200:4;9312:6;9306:13;9355:6;9350:2;9339:9;9335:18;9328:34;9414:6;9409:2;9401:6;9397:15;9392:2;9381:9;9377:18;9371:50;9470:1;9465:2;9456:6;9445:9;9441:22;9437:31;9430:42;9599:2;-1:-1:-1;;9524:2:7;9516:6;9512:15;9508:88;9497:9;9493:104;9489:113;9481:121;;;9062:546;;;;;:::o;9823:168::-;9896:9;;;9927;;9944:15;;;9938:22;;9924:37;9914:71;;9965:18;;:::i","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122067fd313fab5c363fc10008d8b7957b153905ffeaba0b005e68db088c53a3ab8b64736f6c63430008220033","offset":6087}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xf5e743e0ea845eb21abbe6cadf5f36d69bf7b8e728b82aac413907281fabafa4","blockNumber":"25283239","transactionIndex":"62","deployer":"0xB0BBff6311B7F245761A7846d3Ce7B1b100C1836"},"sources":{"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)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @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 :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev 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 :=\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            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)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(\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                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), 0xa0, 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"},"src/OpenRouter.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport {IERC20} from \"./common/interfaces/IERC20.sol\";\nimport {AllowanceHolderContext} from \"./common/allowance/AllowanceHolderContext.sol\";\nimport {ALLOWANCE_HOLDER} from \"./common/interfaces/IAllowanceHolder.sol\";\nimport {BytesSpliceLib} from \"./common/lib/BytesSpliceLib.sol\";\nimport {CurrencyLib} from \"./common/lib/CurrencyLib.sol\";\n\n/// @title OpenRouter\n/// @notice Pull → optional fee → swap/bridge execution without backend signature verification.\n///         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):\n///         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of\n///         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.\ncontract OpenRouter is AllowanceHolderContext {\n    using SafeTransferLib for address;\n\n    // =========================================================================\n    // Structs\n    // =========================================================================\n\n    struct InputData {\n        address user;\n        address inputToken;\n        uint256 inputAmount;\n    }\n\n    struct FeeData {\n        address receiver;\n        uint256 amount;\n    }\n\n    struct SwapData {\n        address target;\n        address approvalSpender;\n        address outputToken;\n        uint256 value;\n        uint256 minOutput;\n        uint256 returnDataWordOffset;\n    }\n\n    struct BridgeData {\n        address target;\n        address approvalSpender;\n        uint256 value;\n    }\n\n    enum CallType {\n        CALL,\n        STATICCALL,\n        CALL_WITH_NATIVE\n    }\n\n    struct Action {\n        /// @dev Packed call metadata. Decode with masks/shifts below; encode with\n        ///      `callType | (storeResult ? 1 << 8 : 0) | (uint160(target) << 16)`.\n        ///\n        /// Bit layout (least significant bits first):\n        ///   bits 255..176 : reserved (0)\n        ///   bits 175..16  : target address (uint160, shifted left by 16 — occupies 160 bits)\n        ///   bit 8         : storeResult — when set, returndata is saved to `results[i]`\n        ///                   even on success so later actions can splice from it\n        ///   bits 7..3     : reserved (0)\n        ///   bits 2..0     : CallType — CALL (0), STATICCALL (1), CALL_WITH_NATIVE (2)\n        ///\n        /// CALL_WITH_NATIVE: first 32 bytes of `data` are forwarded as `msg.value`;\n        /// the remaining bytes are the call payload.\n        uint256 actionInfo;\n        /// @dev Calldata passed to the target. Splices from `splices[]` overwrite byte\n        /// ranges in a mutable memory copy before the external call runs.\n        bytes data;\n        /// @dev Packed splice descriptors applied to `data` before the call.\n        /// Each entry is one `uint256` with four uint64 fields (see layout below).\n        /// Encode with `packSpliceInfo` in `scripts/e2e/utils/modularActionsBuilder/index.js`.\n        ///\n        /// Per-entry bit layout (least significant bits first):\n        ///   bits 255..192 : length — number of bytes to copy (must be > 0)\n        ///   bits 191..128 : dstOffset — byte offset into this action's `data` payload\n        ///                   (skips the bytes-array length word; for CALL_WITH_NATIVE,\n        ///                   offset 0 is the value word, offset 32 is payload start)\n        ///   bits 127..64  : srcOffset — byte offset into `results[sourceActionIndex]`\n        ///                   payload (same length-prefix convention)\n        ///   bits 63..0    : sourceActionIndex — index of a prior action (< current index)\n        ///\n        /// Packing formula:\n        ///   sourceActionIndex | (srcOffset << 64) | (dstOffset << 128) | (length << 192)\n        ///\n        /// The source action must have bit 8 set in `actionInfo` (storeResult); the JS\n        /// builder sets this automatically when a splice references that action.\n        uint256[] splices;\n    }\n\n    // =========================================================================\n    // Flags (swap / swapAndBridge)\n    // =========================================================================\n    //\n    // Instead of bool parameters, one uint256 packs independent switches without adding\n    // ABI range checks or extra words for standalone bools.\n    //\n    // Bit layout (least significant bits); test with `(flags & MASK) != 0`:\n    //   bits 255..32 : reserved (0)\n    //   bits 31..16 : bridge amount word byte offset, uint16, used only when bit 3 is set\n    //   bits 15..4  : reserved (0)\n    //   bit 3     : BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK (0x08) — splice finalAmount into bridge calldata\n    //   bit 2     : BRIDGE_VALUE_FLAG_BIT_MASK (0x04) — bridge msg.value: bridge.value alone vs finalAmount + bridge.value\n    //   bit 1     : BALANCE_FLAG_BIT_MASK (0x02) — swap output: returndata vs balance delta\n    //   bit 0     : POST_FEE_FLAG_BIT_MASK (0x01)   — swap fee: pre- vs post-swap\n    //\n    // Combined values for flags:\n    //\n    //   flags  binary (low byte)    postFee?   balance-of output?            bridge value?\n    //   ─────  ──────────────────  ────────   ──────────────────             ─────────────\n    //   0x00   00000000              no         returndata word               bridge.value\n    //   0x01   00000001              yes        returndata word               bridge.value\n    //   0x02   00000010              no         balance delta on outputToken  bridge.value\n    //   0x03   00000011              yes        balance delta on outputToken  bridge.value\n    //   0x04   00000100              no         returndata word               finalAmount + bridge.value\n    //\n    // POST_FEE_FLAG_BIT_MASK selects bit 0 — fee timing\n    //   0000 — pre-swap fee: pull → deduct fee from input token → swap remainder\n    //   0001 — post-swap fee: pull → swap full input → deduct fee from output token (after minOutput check on swap result)\n    //\n    // BALANCE_FLAG_BIT_MASK selects bit 1 — swap output sizing\n    //   0000 — returnData as swap output: decode returned amount from call returndata at `swapData.returnDataWordOffset`\n    //   0010 — balanceOf() delta as swap output: snapshot outputToken balance before call, measure (after − before) as output\n    //\n    // BRIDGE_VALUE_FLAG_BIT_MASK selects bit 2 — bridge native value source\n    //   0000 — bridge.value as msg.value: forward `bridge.value` as msg.value\n    //   0100 — finalAmount + bridge.value as msg.value: forward `finalAmount + bridge.value` as msg.value (bridge.value carries static addend, e.g. LZ nativeFee)\n    //\n    // BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK selects bit 3 — bridge calldata amount splicing.\n    //   0000 — no bridge calldata modification\n    //   1000 — bridge calldata modification: splice finalAmount at uint16(flags >> BRIDGE_AMOUNT_POSITION_SHIFT)\n    //\n\n    /// @dev Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token.\n    uint256 internal constant POST_FEE_FLAG_BIT_MASK = 0x01;\n\n    /// @dev Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word.\n    uint256 internal constant BALANCE_FLAG_BIT_MASK = 0x02;\n\n    /// @dev Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee).\n    uint256 internal constant BRIDGE_VALUE_FLAG_BIT_MASK = 0x04;\n\n    /// @dev Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK = 0x08;\n\n    /// @dev Shift for the packed uint16 bridge amount position.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_SHIFT = 16;\n\n    /// @dev Mask for the packed uint16 bridge amount position after shifting.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_MASK = 0xffff;\n\n    // =========================================================================\n    // Errors\n    // =========================================================================\n\n    error SwapOutputInsufficient();\n    error CallerNotSignedUser();\n    error InsufficientMsgValue();\n    error FutureSplice(uint256 actionIndex, uint256 sourceActionIndex);\n    error SpliceOutOfBounds(uint256 actionIndex, uint256 spliceIndex);\n    error CallFailed(uint256 actionIndex, bytes returndata);\n    error MissingNativeValue(uint256 actionIndex);\n    error ReturnDataOutOfBounds();\n\n    // =========================================================================\n    // Events\n    // =========================================================================\n\n    event RequestExecuted(bytes32 indexed quoteId);\n\n    /// @notice Accepts native ETH forwarded with bridge/swap calls.\n    receive() external payable {}\n\n    // =========================================================================\n    // External functions\n    // =========================================================================\n\n    /**\n     * @notice Perform swap with optional pre/post fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param flags Packed flags\n     * @param input User, input token, and pull amount.\n     * @dev For pre-fee / no-fee: the swap router must\n     *      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.\n     *      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param receiver Address that ultimately receives the swap output (net of any post-swap fee).\n     * @return finalAmount Gross swap output sent to receiver after any post-swap fee\n     * @dev `minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.\n     *      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.\n     */\n    function swap(\n        bytes32 quoteId,\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        address receiver\n    ) external payable returns (uint256 finalAmount) {\n        // Parse flags\n        bool postFee = fee.amount != 0 && ((flags & POST_FEE_FLAG_BIT_MASK) != 0);\n        bool useBalanceOf = ((flags & BALANCE_FLAG_BIT_MASK) != 0);\n\n        {\n            // Pull funds from user via AllowanceHolder\n            _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n            // Collect pre-swap fee\n            uint256 swapInput = input.inputAmount;\n            if (fee.amount != 0 && !postFee) {\n                uint256 feeAmount = fee.amount;\n                CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n                unchecked {\n                    swapInput -= feeAmount;\n                }\n            }\n\n            // Approve spender\n            if (\n                // check spender & token\n                swapData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                    // check current allowance\n                    swapInput > IERC20(input.inputToken).allowance(address(this), swapData.approvalSpender)\n            ) {\n                // approve max allowance\n                SafeTransferLib.safeApproveWithRetry(input.inputToken, swapData.approvalSpender, type(uint256).max);\n            }\n        }\n\n        /// @dev Pre-fee / no-fee: swap calldata encodes `receiver` as the output recipient; tokens never touch this contract.\n        /// @dev Post-fee: swap output lands at this contract so the fee can be deducted before forwarding.\n        address outputReceiver = postFee ? address(this) : receiver;\n\n        // Execute swap\n        finalAmount = _execSwap(swapData, swapCallData, useBalanceOf, outputReceiver);\n        if (finalAmount < swapData.minOutput) revert SwapOutputInsufficient();\n\n        if (postFee) {\n            // Collect post-swap fee\n            uint256 feeAmount = fee.amount;\n            CurrencyLib.transfer(swapData.outputToken, fee.receiver, feeAmount);\n            unchecked {\n                finalAmount -= feeAmount;\n            }\n\n            // Transfer net output to receiver\n            CurrencyLib.transfer(swapData.outputToken, receiver, finalAmount);\n        }\n\n        // Pre-fee / no-fee: tokens were sent directly to `receiver` by the swap router; nothing to transfer\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Perform swap and bridge with optional pre/post swap fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param flags Packed flags\n     * @param input User, input token, and pull amount.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param bridgeData Bridge target, approval spender, and static `msg.value` addend.\n     * @param bridgeCallData Bridge calldata; optionally spliced with swap output per `flags`.\n     * @dev Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies.\n     */\n    function swapAndBridge(\n        bytes32 quoteId,\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) external payable {\n        // Execute swap before bridge\n        uint256 finalAmount = _swapBeforeBridge(flags, input, fee, swapData, swapCallData);\n\n        // Execute bridge\n        _execBridge(swapData.outputToken, finalAmount, flags, bridgeData, bridgeCallData);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Perform bridge with optional pre-bridge fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param input User, input token, and pull amount.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param bridgeData Bridge target, approval spender, and `msg.value` for the bridge call.\n     * @param bridgeCallData Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller).\n     * @dev Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.\n     *      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.\n     *      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`.\n     */\n    function bridge(\n        bytes32 quoteId,\n        InputData calldata input,\n        FeeData calldata fee,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) external payable {\n        // Pull funds from user via AllowanceHolder\n        _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n        // Collect pre-bridge fee\n        uint256 feeAmount = fee.amount;\n        if (feeAmount != 0) {\n            CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n        }\n\n        uint256 netAmount;\n        unchecked {\n            netAmount = input.inputAmount - feeAmount;\n        }\n\n        // Approve bridge spender\n        if (\n            // check spender && token\n            bridgeData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                // check current allowance\n                netAmount > IERC20(input.inputToken).allowance(address(this), bridgeData.approvalSpender)\n        ) {\n            // approve max allowance\n            SafeTransferLib.safeApproveWithRetry(input.inputToken, bridgeData.approvalSpender, type(uint256).max);\n        }\n\n        // Execute bridge\n        _execCallCalldata(bridgeData.target, bridgeData.value, bridgeCallData, false);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Runs a sequence of generic actions with optional returndata splicing between steps.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param actions Ordered actions; each may splice bytes from a prior action's returndata into its calldata.\n     */\n    function performActions(bytes32 quoteId, Action[] calldata actions) external payable {\n        _performActions(actions);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    // =========================================================================\n    // Internal functions\n    // =========================================================================\n\n    // -------------------------------------\n    //   swapAndBridge internal functions\n    // -------------------------------------\n\n    /**\n     * @dev Pull, optional pre/post swap fee, and swap for `swapAndBridge`. Swap output always remains at `address(this)` for bridging.\n     * @param flags Fee timing and swap output measurement flags (same as `swap`).\n     * @param input User, input token, and pull amount.\n     * @param fee Fee receiver and amount; `amount == 0` skips fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @return finalAmount Swap output net of any post-swap fee, ready for `_execBridge`.\n     */\n    function _swapBeforeBridge(\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData\n    ) internal returns (uint256 finalAmount) {\n        // Pull funds from user via AllowanceHolder\n        _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n        bool postFee;\n        {\n            // Collect pre-swap fee\n            uint256 feeAmount = fee.amount;\n            postFee = feeAmount != 0 && ((flags & POST_FEE_FLAG_BIT_MASK) != 0);\n            uint256 swapInput = input.inputAmount;\n\n            if (feeAmount != 0 && !postFee) {\n                CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n                unchecked {\n                    swapInput -= feeAmount;\n                }\n            }\n\n            // Approve swap spender\n            if (\n                // check spender & token\n                swapData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                    // check current allowance\n                    swapInput > IERC20(input.inputToken).allowance(address(this), swapData.approvalSpender)\n            ) {\n                // approve max allowance\n                SafeTransferLib.safeApproveWithRetry(input.inputToken, swapData.approvalSpender, type(uint256).max);\n            }\n        }\n\n        // Execute swap\n        /// @dev Swap output always lands at this contract regardless of fee timing — tokens must be here for bridging.\n        bool useBalanceOf = ((flags & BALANCE_FLAG_BIT_MASK) != 0);\n        finalAmount = _execSwap(swapData, swapCallData, useBalanceOf, address(this));\n        if (finalAmount < swapData.minOutput) revert SwapOutputInsufficient();\n\n        // Collect post-swap fee\n        if (postFee) {\n            uint256 feeAmount = fee.amount;\n            CurrencyLib.transfer(swapData.outputToken, fee.receiver, feeAmount);\n            unchecked {\n                finalAmount -= feeAmount;\n            }\n        }\n    }\n\n    /**\n     * @dev Splice `amount` into bridge calldata when flagged, approve the bridge spender, and call the bridge target.\n     * @param token ERC-20 bridged (or native sentinel); used for approval only.\n     * @param amount Post-swap token amount spliced into calldata and/or forwarded as `msg.value`.\n     * @param flags Bridge splice position, `msg.value` composition, and related bit flags.\n     * @param bridgeData Bridge target, approval spender, and static `msg.value` addend.\n     * @param bridgeCallData Base bridge calldata; copied to memory when splicing is required.\n     */\n    function _execBridge(\n        address token,\n        uint256 amount,\n        uint256 flags,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) internal {\n        bytes memory _bridgeCallData = bridgeCallData;\n\n        // Modify bridge calldata if splicing is required\n        if (flags & BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK != 0) {\n            uint256 position = flags >> BRIDGE_AMOUNT_POSITION_SHIFT & BRIDGE_AMOUNT_POSITION_MASK;\n            BytesSpliceLib.spliceWord({data: _bridgeCallData, position: position, word: amount});\n        }\n\n        // Approve bridge spender\n        if (\n            // check spender & token\n            bridgeData.approvalSpender != address(0) && token != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                // check current allowance\n                amount > IERC20(token).allowance(address(this), bridgeData.approvalSpender)\n        ) {\n            // approve max allowance\n            SafeTransferLib.safeApproveWithRetry(token, bridgeData.approvalSpender, type(uint256).max);\n        }\n\n        // Parse and set bridge value flag\n        uint256 bridgeValue = ((flags & BRIDGE_VALUE_FLAG_BIT_MASK) != 0) ? amount + bridgeData.value : bridgeData.value;\n\n        // Execute bridge call\n        _execCall(bridgeData.target, bridgeValue, _bridgeCallData);\n    }\n\n    // --------------------------------------\n    //   performActions internal functions\n    // --------------------------------------\n\n    /**\n     * @dev Executes `actions` in order, applying returndata splices before each call.\n     * @dev See `Action` for `actionInfo` and `splices[]` bit layouts.\n     * @param actions Ordered list of actions to run.\n     */\n    function _performActions(Action[] calldata actions) internal {\n        uint256 actionsLength = actions.length;\n        bytes[] memory results = new bytes[](actionsLength);\n\n        for (uint256 i; i < actionsLength;) {\n            Action calldata action = actions[i];\n            bytes memory callData = action.data;\n\n            // Patch callData with slices of prior action returndata.\n            uint256 splicesLength = action.splices.length;\n            for (uint256 j; j < splicesLength;) {\n                uint256 spliceInfo = action.splices[j];\n                uint256 sourceActionIndex = uint64(spliceInfo); // first 64 bits: index of the prior action to read returndata from.\n                if (sourceActionIndex >= i) revert FutureSplice(i, sourceActionIndex);\n\n                uint256 srcOffset = uint64(spliceInfo >> 64); // Next 64 bits: byte offset into source returndata\n                uint256 dstOffset = uint64(spliceInfo >> 128); // Next 64 bits: byte offset into next action's data\n                uint256 length = spliceInfo >> 192; // Top 64 bits: number of bytes to copy\n\n                // Fetch source action returndata\n                bytes memory source = results[sourceActionIndex];\n                if (srcOffset + length > source.length || dstOffset + length > callData.length) {\n                    revert SpliceOutOfBounds(i, j);\n                }\n\n                assembly (\"memory-safe\") {\n                    // copy `length` bytes from `source returndata starting from `srcOffset` to `callData` starting from `dstOffset`\n                    mcopy(add(add(callData, 0x20), dstOffset), add(add(source, 0x20), srcOffset), length)\n                }\n\n                unchecked {\n                    ++j;\n                }\n            }\n\n            // Parse actionInfo\n            bool success;\n            uint256 actionInfo = action.actionInfo;\n            bool storeResult = (actionInfo & 0xff00) != 0; // Bit 8: persist returndata if set\n            uint256 callType = actionInfo & 0xff; // Bits 0–7: specify CallType\n            address target = address(uint160(actionInfo >> 16)); // Bits 16+: target address\n\n            if (callType == uint256(CallType.STATICCALL)) {\n                assembly (\"memory-safe\") {\n                    // staticcall without copying return data by default\n                    success := staticcall(gas(), target, add(callData, 0x20), mload(callData), 0, 0)\n                }\n            } else if (callType == uint256(CallType.CALL_WITH_NATIVE)) {\n                if (callData.length < 32) revert MissingNativeValue(i);\n                uint256 callValue;\n                uint256 payloadLength = callData.length - 32;\n                assembly (\"memory-safe\") {\n                    // regular call with value forwarded without copying return data by default\n                    callValue := mload(add(callData, 0x20)) // CALL_WITH_NATIVE prepends a 32-byte wei amount before the actual calldata payload.\n                    success := call(gas(), target, callValue, add(callData, 0x40), payloadLength, 0, 0) // skips first two bytes to reach actuall calldata\n                }\n            } else {\n                assembly (\"memory-safe\") {\n                    // regular call with zero value forwarded without copying return data by default\n                    success := call(gas(), target, 0, add(callData, 0x20), mload(callData), 0, 0)\n                }\n            }\n\n            // Capture returndata on failure (for revert reason) or when explicitly requested.\n            if (!success || storeResult) {\n                bytes memory ret;\n                assembly (\"memory-safe\") {\n                    // prep return / revert data\n                    let returnDataSize := returndatasize()\n                    ret := mload(0x40)\n                    mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                    returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                    mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // Advance free pointer to next 32-byte boundary: (ret + 0x20 + size + 31) and clear last 5 bits with not(0x1f)\n                }\n                // if any call was failed, revert with the returndata\n                if (!success) revert CallFailed(i, ret);\n                \n                // else, save returndata to results array\n                results[i] = ret;\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    // -------------------------------\n    //   Common internal functions\n    // -------------------------------\n\n    /**\n     * @dev Pulls `amount` of `token` from `user` into this contract.\n     *      For ERC20: enforces `_msgSender() == user` (caller must have routed through `AllowanceHolder.exec`) and calls AH.transferFrom via assembly.\n     *      AH selector: transferFrom(address,address,address,uint256) = 0x15dacbea.\n     *      For native ETH: ETH must already be present as msg.value; verify sufficient value was forwarded.\n     * @param token Input token or `CurrencyLib.NATIVE_TOKEN_ADDRESS`.\n     * @param user Owner whose AllowanceHolder-scoped allowance is consumed.\n     * @param amount Tokens or wei to pull.\n     */\n    function _pullFromUser(address token, address user, uint256 amount) internal {\n        // Check input value if native token\n        if (token == CurrencyLib.NATIVE_TOKEN_ADDRESS) {\n            if (msg.value < amount) {\n                revert InsufficientMsgValue();\n            }\n            return;\n        }\n\n        // Check caller is user\n        if (_msgSender() != user) revert CallerNotSignedUser();\n\n        // Call AllowanceHolder.transferFrom()\n        address allowanceHolder = address(ALLOWANCE_HOLDER);\n        assembly (\"memory-safe\") {\n            // Manually ABI-encode AllowanceHolder.transferFrom(address token, address owner, address recipient, uint256 amount)\n            // selector 0x15dacbea. Calldata is 0x84 (132) bytes and starts at ptr+0x1c (see last mstore below).\n            //\n            // The `shl(0x60, addr)` trick left-aligns a 20-byte address in a 32-byte word: the high 20 bytes\n            // hold the address and the trailing 12 bytes are zero, which simultaneously encodes the address AND\n            // provides the ABI zero-padding for the *next* field — so each shifted mstore clears the following\n            // field's padding without a separate write.\n            //\n            // Calldata layout relative to ptr+0x1c:\n            //   [0..3]    selector   (0x15dacbea)\n            //   [4..35]   token      (12-byte pad + 20-byte address)\n            //   [36..67]  owner/user (12-byte pad + 20-byte address)\n            //   [68..99]  recipient  (12-byte pad + 20-byte address = address(this))\n            //   [100..131] amount    (uint256)\n            let ptr := mload(0x40)\n            mstore(add(0x80, ptr), amount) // calldata[100..131]: amount (uint256, right-aligned)\n            mstore(add(0x60, ptr), address()) // calldata[68..99]: recipient = this contract (right-aligned, high 12 bytes are zero padding)\n            mstore(add(0x4c, ptr), shl(0x60, user)) // calldata[48..67]: user address; trailing 12 zero bytes fill calldata[68..79] (recipient padding)\n            // `shl(0x60)` (96-bit), NOT `shl(0xa0)` (160-bit): 0xa0 here is literal 160, which\n            // shifts the 20-byte address out of place and corrupts the calldata token. Same as 0x-settler `Permit2Payment._allowanceHolderTransferFrom`.\n            mstore(add(0x2c, ptr), shl(0x60, token)) // calldata[16..35]: token address; trailing 12 zero bytes fill calldata[36..47] (user padding)\n            mstore(add(0x0c, ptr), 0x15dacbea000000000000000000000000) // selector at calldata[0..3]; 12 zero bytes fill calldata[4..15] (token padding); calldata begins at ptr+0x1c\n\n            if iszero(call(gas(), allowanceHolder, 0x00, add(0x1c, ptr), 0x84, 0x00, 0x00)) {\n                // if call did not succeed, revert with the revert returndata\n                let p := mload(0x40)\n                returndatacopy(p, 0x00, returndatasize())\n                revert(p, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev Executes the swap call and returns the output amount.\n     *      `useBalanceOf=true`: measure output as (balance after − balance before) at `outputReceiver`.\n     *      `useBalanceOf=false`: decode output from returndata at `swapData.returnDataWordOffset`.\n     *      `outputReceiver` must be `address(this)` when tokens are expected at the contract (post-swap fee path, bridge path)\n     *      or the end user when the router sends directly to them.\n     * @param swapData Swap target, value, output token, and returndata layout.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param useBalanceOf When true, use balance delta instead of returndata decoding.\n     * @param outputReceiver Account whose output-token balance is measured or credited.\n     * @return finalAmount Gross swap output amount.\n     */\n    function _execSwap(\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        bool useBalanceOf,\n        address outputReceiver\n    ) internal returns (uint256 finalAmount) {\n        if (useBalanceOf) {\n            // Measure output as (balance after − balance before) at `outputReceiver`\n            uint256 before = CurrencyLib.balanceOf(swapData.outputToken, outputReceiver);\n            _execCallCalldata(swapData.target, swapData.value, swapCallData, false);\n            finalAmount = CurrencyLib.balanceOf(swapData.outputToken, outputReceiver) - before;\n        } else {\n            // Decode output from returndata\n            bytes memory ret = _execCallCalldata(swapData.target, swapData.value, swapCallData, true);\n            finalAmount = _decodeReturnWord(ret, swapData.returnDataWordOffset);\n        }\n    }\n\n    /**\n     * @dev Low-level `call` with bubbled revert data on failure.\n     * @param target Call recipient.\n     * @param value Wei forwarded with the call.\n     * @param data ABI-encoded calldata in memory.\n     */\n    function _execCall(address target, uint256 value, bytes memory data) internal {\n        bool success;\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0, 0)\n        }\n\n        if (!success) {\n            bytes memory ret;\n            assembly (\"memory-safe\") {\n                // prep and return revert data\n                let returnDataSize := returndatasize()\n                ret := mload(0x40)\n                mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // bump free pointer\n                revert(add(ret, 0x20), mload(ret)) // bubbles up the original revert payload\n            }\n        }\n    }\n\n    /**\n     * @dev Low-level `call` using calldata copied to memory; optionally captures returndata.\n     * @dev Helps cheaper external calls avoiding early copy of calldata to memory.\n     * @param target Call recipient.\n     * @param value Wei forwarded with the call.\n     * @param data Calldata slice forwarded to `target`.\n     * @param storeResult When true, copy returndata into memory even on success.\n     * @return ret Returndata when `storeResult` is true or the call reverts (revert bubbles).\n     */\n    function _execCallCalldata(address target, uint256 value, bytes calldata data, bool storeResult)\n        internal\n        returns (bytes memory ret)\n    {\n        bool success;\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            calldatacopy(ptr, data.offset, data.length) // copy calldata slice to fresh memory (avoids redundant memory alloc)\n            mstore(0x40, and(add(add(ptr, data.length), 0x1f), not(0x1f))) // advance free pointer to next 32-byte boundary\n            success := call(gas(), target, value, ptr, data.length, 0, 0)\n        }\n\n        if (!success || storeResult) {\n            assembly (\"memory-safe\") {\n                // prep and return revert data\n                let returnDataSize := returndatasize()\n                ret := mload(0x40)\n                mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // bump free pointer\n            }\n            if (!success) {\n                assembly (\"memory-safe\") {\n                    revert(add(ret, 0x20), mload(ret)) // bubble up the raw revert payload\n                }\n            }\n        }\n    }\n\n    /**\n     * @dev Reads the 32-byte word at `wordOffset` from ABI-encoded `ret` (word index, not byte offset).\n     * @param ret Return blob from a prior call.\n     * @param wordOffset Zero-based index of the 32-byte word to load.\n     * @return word Decoded amount or value at that offset.\n     */\n    function _decodeReturnWord(bytes memory ret, uint256 wordOffset) internal pure returns (uint256 word) {\n        uint256 offset = wordOffset * 32;\n        if (offset + 32 > ret.length) revert ReturnDataOutOfBounds();\n\n        assembly (\"memory-safe\") {\n            // read the word at the offset from return data\n            word := mload(add(add(ret, 0x20), offset))\n        }\n    }\n}\n"},"src/common/allowance/AllowanceHolderContext.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.34;\n\nimport {ALLOWANCE_HOLDER} from \"../interfaces/IAllowanceHolder.sol\";\n\n/// @title AllowanceHolderContext\n/// @notice Self-contained port of 0x-settler's AllowanceHolderContext. Provides\n///         `_msgSender()` that returns the original user when this contract is\n///         called via `AllowanceHolder.exec(...)` (which appends the user's\n///         address as the last 20 bytes of calldata, ERC-2771 style).\n///         Also exposes the dummy `balanceOf(address)` so AllowanceHolder's\n///         confused-deputy probe (it tries to call `balanceOf` on the target\n///         to detect whether `target` looks like an ERC20) does not reject the\n///         call.\nabstract contract AllowanceHolderContext {\n    /// @notice Returns the effective msg.sender. When the immediate caller is\n    ///         `AllowanceHolder`, the trusted forwarder, the real user is\n    ///         decoded from the last 20 bytes of calldata.\n    function _msgSender() internal view virtual returns (address sender) {\n        sender = msg.sender;\n        if (sender == address(ALLOWANCE_HOLDER)) {\n            // ERC-2771 style: AllowanceHolder appends the user's address as\n            // the trailing 20 bytes of calldata after invoking target.\n            assembly (\"memory-safe\") {\n                sender := shr(0x60, calldataload(sub(calldatasize(), 0x14)))\n            }\n        }\n    }\n\n    /// @notice True if the call was forwarded by AllowanceHolder.\n    function _isForwarded() internal view virtual returns (bool) {\n        return msg.sender == address(ALLOWANCE_HOLDER);\n    }\n\n    /// @notice msg.data with the trailing 20-byte user address stripped when\n    ///         the call was forwarded by AllowanceHolder.\n    function _msgData() internal view virtual returns (bytes calldata) {\n        if (msg.sender == address(ALLOWANCE_HOLDER)) {\n            return msg.data[:msg.data.length - 20];\n        }\n        return msg.data;\n    }\n\n    /// @notice Dummy `balanceOf` implementation. AllowanceHolder probes its\n    ///         `target` with `IERC20.balanceOf(...)` and reverts if the call\n    ///         returns 32 bytes (i.e. target looks like an ERC20). We return\n    ///         a single-byte return so the check passes, mirroring 0x-settler.\n    function balanceOf(address) external pure {\n        assembly (\"memory-safe\") {\n            mstore8(0x00, 0x00)\n            return(0x00, 0x01)\n        }\n    }\n}\n"},"src/common/interfaces/IAllowanceHolder.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.34;\n\n// @dev Socket CREATE3 AllowanceHolder address. Chain-specific OpenRouter builds\n//      patch this constant before compilation when needed.\nIAllowanceHolder constant ALLOWANCE_HOLDER = IAllowanceHolder(0x50c4E75a512F2A14A7b304787Adf79C4531A5909);\n\n/// @title IAllowanceHolder\n/// @notice External-facing interface of 0x's AllowanceHolder contract.\n///         Mirrors `0x-settler/src/allowanceholder/IAllowanceHolder.sol`.\ninterface IAllowanceHolder {\n    /// @notice The user calls `exec(operator, token, amount, target, data)` on\n    ///         AllowanceHolder. AllowanceHolder writes a transient allowance for\n    ///         `(operator, msgSender, token)` of `amount`, then calls `target`\n    ///         with `data` and the user's address appended ERC-2771-style.\n    function exec(address operator, address token, uint256 amount, address payable target, bytes calldata data)\n        external\n        payable\n        returns (bytes memory result);\n\n    /// @notice Counterpart to `exec`. Called by `operator` (the OpenRouter)\n    ///         to consume the transient allowance and pull `amount` of\n    ///         `token` from `owner` to `recipient`.\n    function transferFrom(address token, address owner, address recipient, uint256 amount) external returns (bool);\n}\n"},"src/common/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\ninterface IERC20 {\n    function allowance(address owner, address spender) external view returns (uint256);\n}\n"},"src/common/lib/BytesSpliceLib.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\n/// @title BytesSpliceLib\n/// @notice Generalisation of the in-place calldata patching. Supports patching\n///         either a single 32-byte word (for `uint256` amount fields) or an\n///         arbitrary length copy from one bytes blob to another.\nlibrary BytesSpliceLib {\n    error SpliceLengthZero();\n    error SpliceSrcOutOfBounds();\n    error SpliceDstOutOfBounds();\n    error SplicePositionOutOfBounds();\n\n    /// @notice Overwrites a 32-byte word at `position` in `data` with `word`.\n    function spliceWord(bytes memory data, uint256 position, uint256 word) internal pure {\n        // Bounds check: position + 32 must fit in data\n        if (position + 32 > data.length) {\n            revert SplicePositionOutOfBounds();\n        }\n        // in-place mstore at data + 32 (skip length prefix) + position\n        assembly (\"memory-safe\") {\n            mstore(add(add(data, 0x20), position), word)\n        }\n    }\n\n    /// @notice Overwrites a 32-byte word at every entry in `positions`.\n    function spliceWords(bytes memory data, uint256[] memory positions, uint256 word) internal pure {\n        uint256 len = positions.length;\n        for (uint256 i = 0; i < len;) {\n            spliceWord({data: data, position: positions[i], word: word});\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    /// @notice Copies `length` bytes from `src` at `srcOffset` into `dst` at `dstOffset`.\n    /// @dev Uses Cancun's `mcopy`. Performs bounds checks on both blobs and\n    ///      rejects zero-length splices to match the safety expectations on\n    ///      the modular OpenRouter actions.\n    function spliceBytes(bytes memory dst, uint256 dstOffset, bytes memory src, uint256 srcOffset, uint256 length)\n        internal\n        pure\n    {\n        if (length == 0) {\n            revert SpliceLengthZero();\n        }\n        // unchecked: revert paths use checked add to keep things readable.\n        if (srcOffset + length > src.length) {\n            revert SpliceSrcOutOfBounds();\n        }\n        if (dstOffset + length > dst.length) {\n            revert SpliceDstOutOfBounds();\n        }\n        assembly (\"memory-safe\") {\n            mcopy(add(add(dst, 0x20), dstOffset), add(add(src, 0x20), srcOffset), length)\n        }\n    }\n}\n"},"src/common/lib/CurrencyLib.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nerror TransferFailed();\n\n// @audit Audited before by Hexens: https://github.com/SocketDotTech/audits/blob/main/Bungee/12-2024%20-%20Bungee%20Protocol%20-%20Hexens.pdf\n/// @title CurrencyLib\n/// @notice Token transfer + balance helpers that treat the canonical native\n///         pseudo-token (`0xEee...EEe`) the same way as the marketplace's\n///         CurrencyLib. Backed by Solady SafeTransferLib for ERC20.\nlibrary CurrencyLib {\n    /// @dev address used to identify native token\n    address internal constant NATIVE_TOKEN_ADDRESS = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);\n\n    function balanceOf(address token, address addr) internal view returns (uint256 balance) {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            balance = addr.balance;\n        } else {\n            balance = SafeTransferLib.balanceOf(token, addr);\n        }\n    }\n\n    function transferFrom(address token, address from, address recipient, uint256 amount) internal {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            _transferNative(recipient, amount);\n        } else {\n            SafeTransferLib.safeTransferFrom(token, from, recipient, amount);\n        }\n    }\n\n    function transfer(address token, address recipient, uint256 amount) internal {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            _transferNative(recipient, amount);\n        } else {\n            SafeTransferLib.safeTransfer(token, recipient, amount);\n        }\n    }\n\n    function _transferNative(address recipient, uint256 amount) private {\n        (bool success,) = recipient.call{value: amount, gas: 27_000}(\"\");\n        if (!success) {\n            revert TransferFailed();\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.34+commit.80d5c536","compilerSettings":{"libraries":{},"optimizer":{"runs":2000,"enabled":true},"evmVersion":"cancun"},"name":"OpenRouter","fullyQualifiedName":"src/OpenRouter.sol:OpenRouter"},"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"returndata","type":"bytes","internalType":"bytes"}]},{"name":"CallerNotSignedUser","type":"error","inputs":[]},{"name":"FutureSplice","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"sourceActionIndex","type":"uint256","internalType":"uint256"}]},{"name":"InsufficientMsgValue","type":"error","inputs":[]},{"name":"MissingNativeValue","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"}]},{"name":"ReturnDataOutOfBounds","type":"error","inputs":[]},{"name":"SpliceOutOfBounds","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"spliceIndex","type":"uint256","internalType":"uint256"}]},{"name":"SplicePositionOutOfBounds","type":"error","inputs":[]},{"name":"SwapOutputInsufficient","type":"error","inputs":[]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"RequestExecuted","type":"event","inputs":[{"name":"quoteId","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"balanceOf","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"pure"},{"name":"bridge","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"bridgeData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.BridgeData"},{"name":"bridgeCallData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"performActions","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"actions","type":"tuple[]","components":[{"name":"actionInfo","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"splices","type":"uint256[]","internalType":"uint256[]"}],"internalType":"struct OpenRouter.Action[]"}],"outputs":[],"stateMutability":"payable"},{"name":"swap","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"flags","type":"uint256","internalType":"uint256"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"swapData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"outputToken","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"minOutput","type":"uint256","internalType":"uint256"},{"name":"returnDataWordOffset","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.SwapData"},{"name":"swapCallData","type":"bytes","internalType":"bytes"},{"name":"receiver","type":"address","internalType":"address"}],"outputs":[{"name":"finalAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swapAndBridge","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"flags","type":"uint256","internalType":"uint256"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"swapData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"outputToken","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"minOutput","type":"uint256","internalType":"uint256"},{"name":"returnDataWordOffset","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.SwapData"},{"name":"swapCallData","type":"bytes","internalType":"bytes"},{"name":"bridgeData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.BridgeData"},{"name":"bridgeCallData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.34+commit.80d5c536"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"actionIndex","type":"uint256"},{"internalType":"bytes","name":"returndata","type":"bytes"}],"name":"CallFailed","type":"error"},{"inputs":[],"name":"CallerNotSignedUser","type":"error"},{"inputs":[{"internalType":"uint256","name":"actionIndex","type":"uint256"},{"internalType":"uint256","name":"sourceActionIndex","type":"uint256"}],"name":"FutureSplice","type":"error"},{"inputs":[],"name":"InsufficientMsgValue","type":"error"},{"inputs":[{"internalType":"uint256","name":"actionIndex","type":"uint256"}],"name":"MissingNativeValue","type":"error"},{"inputs":[],"name":"ReturnDataOutOfBounds","type":"error"},{"inputs":[{"internalType":"uint256","name":"actionIndex","type":"uint256"},{"internalType":"uint256","name":"spliceIndex","type":"uint256"}],"name":"SpliceOutOfBounds","type":"error"},{"inputs":[],"name":"SplicePositionOutOfBounds","type":"error"},{"inputs":[],"name":"SwapOutputInsufficient","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"quoteId","type":"bytes32"}],"name":"RequestExecuted","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes32","name":"quoteId","type":"bytes32"},{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"}],"internalType":"struct OpenRouter.InputData","name":"input","type":"tuple"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct OpenRouter.FeeData","name":"fee","type":"tuple"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"approvalSpender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct OpenRouter.BridgeData","name":"bridgeData","type":"tuple"},{"internalType":"bytes","name":"bridgeCallData","type":"bytes"}],"name":"bridge","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"quoteId","type":"bytes32"},{"components":[{"internalType":"uint256","name":"actionInfo","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"},{"internalType":"uint256[]","name":"splices","type":"uint256[]"}],"internalType":"struct OpenRouter.Action[]","name":"actions","type":"tuple[]"}],"name":"performActions","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"quoteId","type":"bytes32"},{"internalType":"uint256","name":"flags","type":"uint256"},{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"}],"internalType":"struct OpenRouter.InputData","name":"input","type":"tuple"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct OpenRouter.FeeData","name":"fee","type":"tuple"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"approvalSpender","type":"address"},{"internalType":"address","name":"outputToken","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"minOutput","type":"uint256"},{"internalType":"uint256","name":"returnDataWordOffset","type":"uint256"}],"internalType":"struct OpenRouter.SwapData","name":"swapData","type":"tuple"},{"internalType":"bytes","name":"swapCallData","type":"bytes"},{"internalType":"address","name":"receiver","type":"address"}],"name":"swap","outputs":[{"internalType":"uint256","name":"finalAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"quoteId","type":"bytes32"},{"internalType":"uint256","name":"flags","type":"uint256"},{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"inputToken","type":"address"},{"internalType":"uint256","name":"inputAmount","type":"uint256"}],"internalType":"struct OpenRouter.InputData","name":"input","type":"tuple"},{"components":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct OpenRouter.FeeData","name":"fee","type":"tuple"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"approvalSpender","type":"address"},{"internalType":"address","name":"outputToken","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"minOutput","type":"uint256"},{"internalType":"uint256","name":"returnDataWordOffset","type":"uint256"}],"internalType":"struct OpenRouter.SwapData","name":"swapData","type":"tuple"},{"internalType":"bytes","name":"swapCallData","type":"bytes"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"approvalSpender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct OpenRouter.BridgeData","name":"bridgeData","type":"tuple"},{"internalType":"bytes","name":"bridgeCallData","type":"bytes"}],"name":"swapAndBridge","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"details":"Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`.","params":{"bridgeCallData":"Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller).","bridgeData":"Bridge target, approval spender, and `msg.value` for the bridge call.","fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`."}},"performActions(bytes32,(uint256,bytes,uint256[])[])":{"params":{"actions":"Ordered actions; each may splice bytes from a prior action's returndata into its calldata.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`."}},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"details":"For pre-fee / no-fee: the swap router must      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.`minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.","params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","receiver":"Address that ultimately receives the swap output (net of any post-swap fee).","swapCallData":"Calldata forwarded to `swapData.target`.","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset."},"returns":{"finalAmount":"Gross swap output sent to receiver after any post-swap fee"}},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"details":"Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies.","params":{"bridgeCallData":"Bridge calldata; optionally spliced with swap output per `flags`.","bridgeData":"Bridge target, approval spender, and static `msg.value` addend.","fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","swapCallData":"Calldata forwarded to `swapData.target`.","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset."}}},"stateVariables":{"BALANCE_FLAG_BIT_MASK":{"details":"Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word."},"BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK":{"details":"Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags."},"BRIDGE_AMOUNT_POSITION_MASK":{"details":"Mask for the packed uint16 bridge amount position after shifting."},"BRIDGE_AMOUNT_POSITION_SHIFT":{"details":"Shift for the packed uint16 bridge amount position."},"BRIDGE_VALUE_FLAG_BIT_MASK":{"details":"Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee)."},"POST_FEE_FLAG_BIT_MASK":{"details":"Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token."}},"title":"OpenRouter","version":1},"userdoc":{"kind":"user","methods":{"balanceOf(address)":{"notice":"Dummy `balanceOf` implementation. AllowanceHolder probes its         `target` with `IERC20.balanceOf(...)` and reverts if the call         returns 32 bytes (i.e. target looks like an ERC20). We return         a single-byte return so the check passes, mirroring 0x-settler."},"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"notice":"Perform bridge with optional pre-bridge fee."},"performActions(bytes32,(uint256,bytes,uint256[])[])":{"notice":"Runs a sequence of generic actions with optional returndata splicing between steps."},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"notice":"Perform swap with optional pre/post fee."},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"notice":"Perform swap and bridge with optional pre/post swap fee."}},"notice":"Pull → optional fee → swap/bridge execution without backend signature verification.         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.","version":1}},"settings":{"compilationTarget":{"src/OpenRouter.sol":"OpenRouter"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":2000},"remappings":[]},"sources":{"solady/src/utils/SafeTransferLib.sol":{"keccak256":"0xf53a25143307304d9de7186f93f11faae3cc4f722c4b088aed6f4f8f87a02f7a","license":"MIT","urls":["bzz-raw://b722c08826ece540bbc4ee9f825aac501282c0900a0a2caa618154d77f23223d","dweb:/ipfs/QmeMsPT5S4vV8f7DYC2eZ7TBCrtRi9cKMsoW6Ca62Uaqwg"]},"src/OpenRouter.sol":{"keccak256":"0x8e3f06d3c7053073d83a90fbdedc239549432b263fce4397b701e34b65a64087","license":"GPL-3.0-only","urls":["bzz-raw://99bb7e565a541f573c6fa2e7b9c7b8fe82138f34768976c071bf9aa026f197f3","dweb:/ipfs/QmcLkmuV6opYvujrJVboyXFDhp8rhWLfq5SBdHRmVjk5dv"]},"src/common/allowance/AllowanceHolderContext.sol":{"keccak256":"0x8c130745dab83f225e99a460a89851bf48682838b0e3d18f409739725ac6bd8e","license":"MIT","urls":["bzz-raw://0437ebb237c1908a2fb08e59373c2d7568d1a028447a97ded90fda0e585cf556","dweb:/ipfs/QmcZtjSCA9qh7Cp7tPjhkffi5GSXK7hpFUqAHSzjcYmvvN"]},"src/common/interfaces/IAllowanceHolder.sol":{"keccak256":"0xaf50059c4806dafab15974253cbb5296170f3f55a40de65da9768f8ce4d3da82","license":"MIT","urls":["bzz-raw://1eaa1aa4c54a003aa0fdec0cf60bbad1bfd508ca972c07fefc8c401d9792c5c4","dweb:/ipfs/QmXb4HrqRSEYrkDBVqAxJJCAGmm5wFirDqwkyvECneTxdb"]},"src/common/interfaces/IERC20.sol":{"keccak256":"0xaf6861d9a1d139fe78365e8c757f1cdd7b6bfcb44390109d57921b6bce83f69a","license":"GPL-3.0-only","urls":["bzz-raw://8c2a5a735ba8e3a23f669010239fca5316f04c97ca688b4556385ca6224c773c","dweb:/ipfs/QmSAbGA8QegmTUgWouSexifn8a2wstwztpF4dxcaJZcZBt"]},"src/common/lib/BytesSpliceLib.sol":{"keccak256":"0x939e73d55bfb6e4d2ff85fc569579e6936fd8108ace3b41e4d62bb4e913fb561","license":"GPL-3.0-only","urls":["bzz-raw://55d40e31397f3eaddecf0863b909f8b964f94c3387aeae58a533e305ae704cad","dweb:/ipfs/QmTEiokk9ECDSH8BBvPBun8ELwahNNfhCR9NREYuNFY998"]},"src/common/lib/CurrencyLib.sol":{"keccak256":"0x6b19af1e8e4f383d9096af17e187c7b9d7e6b56d418d0c0f5acf73b7661f4f45","license":"GPL-3.0-only","urls":["bzz-raw://4066f96169d3117122eb7804bf717d4b333202bc26042ce2d427a8f0c135ea5f","dweb:/ipfs/QmPmh2HHZKXQWJWfzcsV9f48F2VqW5Y4g8MXCwYxCScgvy"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Pull → optional fee → swap/bridge execution without backend signature verification.         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.","methods":{"balanceOf(address)":{"notice":"Dummy `balanceOf` implementation. AllowanceHolder probes its         `target` with `IERC20.balanceOf(...)` and reverts if the call         returns 32 bytes (i.e. target looks like an ERC20). We return         a single-byte return so the check passes, mirroring 0x-settler."},"performActions(bytes32,(uint256,bytes,uint256[])[])":{"notice":"Runs a sequence of generic actions with optional returndata splicing between steps."},"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"notice":"Perform bridge with optional pre-bridge fee."},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"notice":"Perform swap with optional pre/post fee."},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"notice":"Perform swap and bridge with optional pre/post swap fee."}},"version":1},"devdoc":{"kind":"dev","title":"OpenRouter","methods":{"performActions(bytes32,(uint256,bytes,uint256[])[])":{"params":{"actions":"Ordered actions; each may splice bytes from a prior action's returndata into its calldata.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`."}},"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","bridgeData":"Bridge target, approval spender, and `msg.value` for the bridge call.","bridgeCallData":"Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller)."},"details":"Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`."},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","receiver":"Address that ultimately receives the swap output (net of any post-swap fee).","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset.","swapCallData":"Calldata forwarded to `swapData.target`."},"details":"For pre-fee / no-fee: the swap router must      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.`minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.","returns":{"finalAmount":"Gross swap output sent to receiver after any post-swap fee"}},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset.","bridgeData":"Bridge target, approval spender, and static `msg.value` addend.","swapCallData":"Calldata forwarded to `swapData.target`.","bridgeCallData":"Bridge calldata; optionally spliced with swap output per `flags`."},"details":"Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies."}},"version":1,"stateVariables":{"BALANCE_FLAG_BIT_MASK":{"details":"Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word."},"POST_FEE_FLAG_BIT_MASK":{"details":"Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token."},"BRIDGE_VALUE_FLAG_BIT_MASK":{"details":"Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee)."},"BRIDGE_AMOUNT_POSITION_MASK":{"details":"Mask for the packed uint16 bridge amount position after shifting."},"BRIDGE_AMOUNT_POSITION_SHIFT":{"details":"Shift for the packed uint16 bridge amount position."},"BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK":{"details":"Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags."}}},"sourceIds":{"src/OpenRouter.sol":{"id":1},"src/common/lib/CurrencyLib.sol":{"id":6},"src/common/interfaces/IERC20.sol":{"id":4},"src/common/lib/BytesSpliceLib.sol":{"id":5},"solady/src/utils/SafeTransferLib.sol":{"id":0},"src/common/interfaces/IAllowanceHolder.sol":{"id":3},"src/common/allowance/AllowanceHolderContext.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"src/OpenRouter.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport {IERC20} from \"./common/interfaces/IERC20.sol\";\nimport {AllowanceHolderContext} from \"./common/allowance/AllowanceHolderContext.sol\";\nimport {ALLOWANCE_HOLDER} from \"./common/interfaces/IAllowanceHolder.sol\";\nimport {BytesSpliceLib} from \"./common/lib/BytesSpliceLib.sol\";\nimport {CurrencyLib} from \"./common/lib/CurrencyLib.sol\";\n\n/// @title OpenRouter\n/// @notice Pull → optional fee → swap/bridge execution without backend signature verification.\n///         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):\n///         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of\n///         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.\ncontract OpenRouter is AllowanceHolderContext {\n    using SafeTransferLib for address;\n\n    // =========================================================================\n    // Structs\n    // =========================================================================\n\n    struct InputData {\n        address user;\n        address inputToken;\n        uint256 inputAmount;\n    }\n\n    struct FeeData {\n        address receiver;\n        uint256 amount;\n    }\n\n    struct SwapData {\n        address target;\n        address approvalSpender;\n        address outputToken;\n        uint256 value;\n        uint256 minOutput;\n        uint256 returnDataWordOffset;\n    }\n\n    struct BridgeData {\n        address target;\n        address approvalSpender;\n        uint256 value;\n    }\n\n    enum CallType {\n        CALL,\n        STATICCALL,\n        CALL_WITH_NATIVE\n    }\n\n    struct Action {\n        /// @dev Packed call metadata. Decode with masks/shifts below; encode with\n        ///      `callType | (storeResult ? 1 << 8 : 0) | (uint160(target) << 16)`.\n        ///\n        /// Bit layout (least significant bits first):\n        ///   bits 255..176 : reserved (0)\n        ///   bits 175..16  : target address (uint160, shifted left by 16 — occupies 160 bits)\n        ///   bit 8         : storeResult — when set, returndata is saved to `results[i]`\n        ///                   even on success so later actions can splice from it\n        ///   bits 7..3     : reserved (0)\n        ///   bits 2..0     : CallType — CALL (0), STATICCALL (1), CALL_WITH_NATIVE (2)\n        ///\n        /// CALL_WITH_NATIVE: first 32 bytes of `data` are forwarded as `msg.value`;\n        /// the remaining bytes are the call payload.\n        uint256 actionInfo;\n        /// @dev Calldata passed to the target. Splices from `splices[]` overwrite byte\n        /// ranges in a mutable memory copy before the external call runs.\n        bytes data;\n        /// @dev Packed splice descriptors applied to `data` before the call.\n        /// Each entry is one `uint256` with four uint64 fields (see layout below).\n        /// Encode with `packSpliceInfo` in `scripts/e2e/utils/modularActionsBuilder/index.js`.\n        ///\n        /// Per-entry bit layout (least significant bits first):\n        ///   bits 255..192 : length — number of bytes to copy (must be > 0)\n        ///   bits 191..128 : dstOffset — byte offset into this action's `data` payload\n        ///                   (skips the bytes-array length word; for CALL_WITH_NATIVE,\n        ///                   offset 0 is the value word, offset 32 is payload start)\n        ///   bits 127..64  : srcOffset — byte offset into `results[sourceActionIndex]`\n        ///                   payload (same length-prefix convention)\n        ///   bits 63..0    : sourceActionIndex — index of a prior action (< current index)\n        ///\n        /// Packing formula:\n        ///   sourceActionIndex | (srcOffset << 64) | (dstOffset << 128) | (length << 192)\n        ///\n        /// The source action must have bit 8 set in `actionInfo` (storeResult); the JS\n        /// builder sets this automatically when a splice references that action.\n        uint256[] splices;\n    }\n\n    // =========================================================================\n    // Flags (swap / swapAndBridge)\n    // =========================================================================\n    //\n    // Instead of bool parameters, one uint256 packs independent switches without adding\n    // ABI range checks or extra words for standalone bools.\n    //\n    // Bit layout (least significant bits); test with `(flags & MASK) != 0`:\n    //   bits 255..32 : reserved (0)\n    //   bits 31..16 : bridge amount word byte offset, uint16, used only when bit 3 is set\n    //   bits 15..4  : reserved (0)\n    //   bit 3     : BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK (0x08) — splice finalAmount into bridge calldata\n    //   bit 2     : BRIDGE_VALUE_FLAG_BIT_MASK (0x04) — bridge msg.value: bridge.value alone vs finalAmount + bridge.value\n    //   bit 1     : BALANCE_FLAG_BIT_MASK (0x02) — swap output: returndata vs balance delta\n    //   bit 0     : POST_FEE_FLAG_BIT_MASK (0x01)   — swap fee: pre- vs post-swap\n    //\n    // Combined values for flags:\n    //\n    //   flags  binary (low byte)    postFee?   balance-of output?            bridge value?\n    //   ─────  ──────────────────  ────────   ──────────────────             ─────────────\n    //   0x00   00000000              no         returndata word               bridge.value\n    //   0x01   00000001              yes        returndata word               bridge.value\n    //   0x02   00000010              no         balance delta on outputToken  bridge.value\n    //   0x03   00000011              yes        balance delta on outputToken  bridge.value\n    //   0x04   00000100              no         returndata word               finalAmount + bridge.value\n    //\n    // POST_FEE_FLAG_BIT_MASK selects bit 0 — fee timing\n    //   0000 — pre-swap fee: pull → deduct fee from input token → swap remainder\n    //   0001 — post-swap fee: pull → swap full input → deduct fee from output token (after minOutput check on swap result)\n    //\n    // BALANCE_FLAG_BIT_MASK selects bit 1 — swap output sizing\n    //   0000 — returnData as swap output: decode returned amount from call returndata at `swapData.returnDataWordOffset`\n    //   0010 — balanceOf() delta as swap output: snapshot outputToken balance before call, measure (after − before) as output\n    //\n    // BRIDGE_VALUE_FLAG_BIT_MASK selects bit 2 — bridge native value source\n    //   0000 — bridge.value as msg.value: forward `bridge.value` as msg.value\n    //   0100 — finalAmount + bridge.value as msg.value: forward `finalAmount + bridge.value` as msg.value (bridge.value carries static addend, e.g. LZ nativeFee)\n    //\n    // BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK selects bit 3 — bridge calldata amount splicing.\n    //   0000 — no bridge calldata modification\n    //   1000 — bridge calldata modification: splice finalAmount at uint16(flags >> BRIDGE_AMOUNT_POSITION_SHIFT)\n    //\n\n    /// @dev Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token.\n    uint256 internal constant POST_FEE_FLAG_BIT_MASK = 0x01;\n\n    /// @dev Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word.\n    uint256 internal constant BALANCE_FLAG_BIT_MASK = 0x02;\n\n    /// @dev Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee).\n    uint256 internal constant BRIDGE_VALUE_FLAG_BIT_MASK = 0x04;\n\n    /// @dev Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK = 0x08;\n\n    /// @dev Shift for the packed uint16 bridge amount position.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_SHIFT = 16;\n\n    /// @dev Mask for the packed uint16 bridge amount position after shifting.\n    uint256 internal constant BRIDGE_AMOUNT_POSITION_MASK = 0xffff;\n\n    // =========================================================================\n    // Errors\n    // =========================================================================\n\n    error SwapOutputInsufficient();\n    error CallerNotSignedUser();\n    error InsufficientMsgValue();\n    error FutureSplice(uint256 actionIndex, uint256 sourceActionIndex);\n    error SpliceOutOfBounds(uint256 actionIndex, uint256 spliceIndex);\n    error CallFailed(uint256 actionIndex, bytes returndata);\n    error MissingNativeValue(uint256 actionIndex);\n    error ReturnDataOutOfBounds();\n\n    // =========================================================================\n    // Events\n    // =========================================================================\n\n    event RequestExecuted(bytes32 indexed quoteId);\n\n    /// @notice Accepts native ETH forwarded with bridge/swap calls.\n    receive() external payable {}\n\n    // =========================================================================\n    // External functions\n    // =========================================================================\n\n    /**\n     * @notice Perform swap with optional pre/post fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param flags Packed flags\n     * @param input User, input token, and pull amount.\n     * @dev For pre-fee / no-fee: the swap router must\n     *      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.\n     *      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param receiver Address that ultimately receives the swap output (net of any post-swap fee).\n     * @return finalAmount Gross swap output sent to receiver after any post-swap fee\n     * @dev `minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.\n     *      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.\n     */\n    function swap(\n        bytes32 quoteId,\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        address receiver\n    ) external payable returns (uint256 finalAmount) {\n        // Parse flags\n        bool postFee = fee.amount != 0 && ((flags & POST_FEE_FLAG_BIT_MASK) != 0);\n        bool useBalanceOf = ((flags & BALANCE_FLAG_BIT_MASK) != 0);\n\n        {\n            // Pull funds from user via AllowanceHolder\n            _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n            // Collect pre-swap fee\n            uint256 swapInput = input.inputAmount;\n            if (fee.amount != 0 && !postFee) {\n                uint256 feeAmount = fee.amount;\n                CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n                unchecked {\n                    swapInput -= feeAmount;\n                }\n            }\n\n            // Approve spender\n            if (\n                // check spender & token\n                swapData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                    // check current allowance\n                    swapInput > IERC20(input.inputToken).allowance(address(this), swapData.approvalSpender)\n            ) {\n                // approve max allowance\n                SafeTransferLib.safeApproveWithRetry(input.inputToken, swapData.approvalSpender, type(uint256).max);\n            }\n        }\n\n        /// @dev Pre-fee / no-fee: swap calldata encodes `receiver` as the output recipient; tokens never touch this contract.\n        /// @dev Post-fee: swap output lands at this contract so the fee can be deducted before forwarding.\n        address outputReceiver = postFee ? address(this) : receiver;\n\n        // Execute swap\n        finalAmount = _execSwap(swapData, swapCallData, useBalanceOf, outputReceiver);\n        if (finalAmount < swapData.minOutput) revert SwapOutputInsufficient();\n\n        if (postFee) {\n            // Collect post-swap fee\n            uint256 feeAmount = fee.amount;\n            CurrencyLib.transfer(swapData.outputToken, fee.receiver, feeAmount);\n            unchecked {\n                finalAmount -= feeAmount;\n            }\n\n            // Transfer net output to receiver\n            CurrencyLib.transfer(swapData.outputToken, receiver, finalAmount);\n        }\n\n        // Pre-fee / no-fee: tokens were sent directly to `receiver` by the swap router; nothing to transfer\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Perform swap and bridge with optional pre/post swap fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param flags Packed flags\n     * @param input User, input token, and pull amount.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param bridgeData Bridge target, approval spender, and static `msg.value` addend.\n     * @param bridgeCallData Bridge calldata; optionally spliced with swap output per `flags`.\n     * @dev Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies.\n     */\n    function swapAndBridge(\n        bytes32 quoteId,\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) external payable {\n        // Execute swap before bridge\n        uint256 finalAmount = _swapBeforeBridge(flags, input, fee, swapData, swapCallData);\n\n        // Execute bridge\n        _execBridge(swapData.outputToken, finalAmount, flags, bridgeData, bridgeCallData);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Perform bridge with optional pre-bridge fee.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param input User, input token, and pull amount.\n     * @param fee Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\n     * @param bridgeData Bridge target, approval spender, and `msg.value` for the bridge call.\n     * @param bridgeCallData Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller).\n     * @dev Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.\n     *      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.\n     *      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`.\n     */\n    function bridge(\n        bytes32 quoteId,\n        InputData calldata input,\n        FeeData calldata fee,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) external payable {\n        // Pull funds from user via AllowanceHolder\n        _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n        // Collect pre-bridge fee\n        uint256 feeAmount = fee.amount;\n        if (feeAmount != 0) {\n            CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n        }\n\n        uint256 netAmount;\n        unchecked {\n            netAmount = input.inputAmount - feeAmount;\n        }\n\n        // Approve bridge spender\n        if (\n            // check spender && token\n            bridgeData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                // check current allowance\n                netAmount > IERC20(input.inputToken).allowance(address(this), bridgeData.approvalSpender)\n        ) {\n            // approve max allowance\n            SafeTransferLib.safeApproveWithRetry(input.inputToken, bridgeData.approvalSpender, type(uint256).max);\n        }\n\n        // Execute bridge\n        _execCallCalldata(bridgeData.target, bridgeData.value, bridgeCallData, false);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    /**\n     * @notice Runs a sequence of generic actions with optional returndata splicing between steps.\n     * @param quoteId Caller-defined correlation id logged in `RequestExecuted`.\n     * @param actions Ordered actions; each may splice bytes from a prior action's returndata into its calldata.\n     */\n    function performActions(bytes32 quoteId, Action[] calldata actions) external payable {\n        _performActions(actions);\n\n        emit RequestExecuted(quoteId);\n    }\n\n    // =========================================================================\n    // Internal functions\n    // =========================================================================\n\n    // -------------------------------------\n    //   swapAndBridge internal functions\n    // -------------------------------------\n\n    /**\n     * @dev Pull, optional pre/post swap fee, and swap for `swapAndBridge`. Swap output always remains at `address(this)` for bridging.\n     * @param flags Fee timing and swap output measurement flags (same as `swap`).\n     * @param input User, input token, and pull amount.\n     * @param fee Fee receiver and amount; `amount == 0` skips fee collection.\n     * @param swapData Swap target, spender, output token, value, `minOutput`, and returndata offset.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @return finalAmount Swap output net of any post-swap fee, ready for `_execBridge`.\n     */\n    function _swapBeforeBridge(\n        uint256 flags,\n        InputData calldata input,\n        FeeData calldata fee,\n        SwapData calldata swapData,\n        bytes calldata swapCallData\n    ) internal returns (uint256 finalAmount) {\n        // Pull funds from user via AllowanceHolder\n        _pullFromUser(input.inputToken, input.user, input.inputAmount);\n\n        bool postFee;\n        {\n            // Collect pre-swap fee\n            uint256 feeAmount = fee.amount;\n            postFee = feeAmount != 0 && ((flags & POST_FEE_FLAG_BIT_MASK) != 0);\n            uint256 swapInput = input.inputAmount;\n\n            if (feeAmount != 0 && !postFee) {\n                CurrencyLib.transfer(input.inputToken, fee.receiver, feeAmount);\n                unchecked {\n                    swapInput -= feeAmount;\n                }\n            }\n\n            // Approve swap spender\n            if (\n                // check spender & token\n                swapData.approvalSpender != address(0) && input.inputToken != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                    // check current allowance\n                    swapInput > IERC20(input.inputToken).allowance(address(this), swapData.approvalSpender)\n            ) {\n                // approve max allowance\n                SafeTransferLib.safeApproveWithRetry(input.inputToken, swapData.approvalSpender, type(uint256).max);\n            }\n        }\n\n        // Execute swap\n        /// @dev Swap output always lands at this contract regardless of fee timing — tokens must be here for bridging.\n        bool useBalanceOf = ((flags & BALANCE_FLAG_BIT_MASK) != 0);\n        finalAmount = _execSwap(swapData, swapCallData, useBalanceOf, address(this));\n        if (finalAmount < swapData.minOutput) revert SwapOutputInsufficient();\n\n        // Collect post-swap fee\n        if (postFee) {\n            uint256 feeAmount = fee.amount;\n            CurrencyLib.transfer(swapData.outputToken, fee.receiver, feeAmount);\n            unchecked {\n                finalAmount -= feeAmount;\n            }\n        }\n    }\n\n    /**\n     * @dev Splice `amount` into bridge calldata when flagged, approve the bridge spender, and call the bridge target.\n     * @param token ERC-20 bridged (or native sentinel); used for approval only.\n     * @param amount Post-swap token amount spliced into calldata and/or forwarded as `msg.value`.\n     * @param flags Bridge splice position, `msg.value` composition, and related bit flags.\n     * @param bridgeData Bridge target, approval spender, and static `msg.value` addend.\n     * @param bridgeCallData Base bridge calldata; copied to memory when splicing is required.\n     */\n    function _execBridge(\n        address token,\n        uint256 amount,\n        uint256 flags,\n        BridgeData calldata bridgeData,\n        bytes calldata bridgeCallData\n    ) internal {\n        bytes memory _bridgeCallData = bridgeCallData;\n\n        // Modify bridge calldata if splicing is required\n        if (flags & BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK != 0) {\n            uint256 position = flags >> BRIDGE_AMOUNT_POSITION_SHIFT & BRIDGE_AMOUNT_POSITION_MASK;\n            BytesSpliceLib.spliceWord({data: _bridgeCallData, position: position, word: amount});\n        }\n\n        // Approve bridge spender\n        if (\n            // check spender & token\n            bridgeData.approvalSpender != address(0) && token != CurrencyLib.NATIVE_TOKEN_ADDRESS && \n                // check current allowance\n                amount > IERC20(token).allowance(address(this), bridgeData.approvalSpender)\n        ) {\n            // approve max allowance\n            SafeTransferLib.safeApproveWithRetry(token, bridgeData.approvalSpender, type(uint256).max);\n        }\n\n        // Parse and set bridge value flag\n        uint256 bridgeValue = ((flags & BRIDGE_VALUE_FLAG_BIT_MASK) != 0) ? amount + bridgeData.value : bridgeData.value;\n\n        // Execute bridge call\n        _execCall(bridgeData.target, bridgeValue, _bridgeCallData);\n    }\n\n    // --------------------------------------\n    //   performActions internal functions\n    // --------------------------------------\n\n    /**\n     * @dev Executes `actions` in order, applying returndata splices before each call.\n     * @dev See `Action` for `actionInfo` and `splices[]` bit layouts.\n     * @param actions Ordered list of actions to run.\n     */\n    function _performActions(Action[] calldata actions) internal {\n        uint256 actionsLength = actions.length;\n        bytes[] memory results = new bytes[](actionsLength);\n\n        for (uint256 i; i < actionsLength;) {\n            Action calldata action = actions[i];\n            bytes memory callData = action.data;\n\n            // Patch callData with slices of prior action returndata.\n            uint256 splicesLength = action.splices.length;\n            for (uint256 j; j < splicesLength;) {\n                uint256 spliceInfo = action.splices[j];\n                uint256 sourceActionIndex = uint64(spliceInfo); // first 64 bits: index of the prior action to read returndata from.\n                if (sourceActionIndex >= i) revert FutureSplice(i, sourceActionIndex);\n\n                uint256 srcOffset = uint64(spliceInfo >> 64); // Next 64 bits: byte offset into source returndata\n                uint256 dstOffset = uint64(spliceInfo >> 128); // Next 64 bits: byte offset into next action's data\n                uint256 length = spliceInfo >> 192; // Top 64 bits: number of bytes to copy\n\n                // Fetch source action returndata\n                bytes memory source = results[sourceActionIndex];\n                if (srcOffset + length > source.length || dstOffset + length > callData.length) {\n                    revert SpliceOutOfBounds(i, j);\n                }\n\n                assembly (\"memory-safe\") {\n                    // copy `length` bytes from `source returndata starting from `srcOffset` to `callData` starting from `dstOffset`\n                    mcopy(add(add(callData, 0x20), dstOffset), add(add(source, 0x20), srcOffset), length)\n                }\n\n                unchecked {\n                    ++j;\n                }\n            }\n\n            // Parse actionInfo\n            bool success;\n            uint256 actionInfo = action.actionInfo;\n            bool storeResult = (actionInfo & 0xff00) != 0; // Bit 8: persist returndata if set\n            uint256 callType = actionInfo & 0xff; // Bits 0–7: specify CallType\n            address target = address(uint160(actionInfo >> 16)); // Bits 16+: target address\n\n            if (callType == uint256(CallType.STATICCALL)) {\n                assembly (\"memory-safe\") {\n                    // staticcall without copying return data by default\n                    success := staticcall(gas(), target, add(callData, 0x20), mload(callData), 0, 0)\n                }\n            } else if (callType == uint256(CallType.CALL_WITH_NATIVE)) {\n                if (callData.length < 32) revert MissingNativeValue(i);\n                uint256 callValue;\n                uint256 payloadLength = callData.length - 32;\n                assembly (\"memory-safe\") {\n                    // regular call with value forwarded without copying return data by default\n                    callValue := mload(add(callData, 0x20)) // CALL_WITH_NATIVE prepends a 32-byte wei amount before the actual calldata payload.\n                    success := call(gas(), target, callValue, add(callData, 0x40), payloadLength, 0, 0) // skips first two bytes to reach actuall calldata\n                }\n            } else {\n                assembly (\"memory-safe\") {\n                    // regular call with zero value forwarded without copying return data by default\n                    success := call(gas(), target, 0, add(callData, 0x20), mload(callData), 0, 0)\n                }\n            }\n\n            // Capture returndata on failure (for revert reason) or when explicitly requested.\n            if (!success || storeResult) {\n                bytes memory ret;\n                assembly (\"memory-safe\") {\n                    // prep return / revert data\n                    let returnDataSize := returndatasize()\n                    ret := mload(0x40)\n                    mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                    returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                    mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // Advance free pointer to next 32-byte boundary: (ret + 0x20 + size + 31) and clear last 5 bits with not(0x1f)\n                }\n                // if any call was failed, revert with the returndata\n                if (!success) revert CallFailed(i, ret);\n                \n                // else, save returndata to results array\n                results[i] = ret;\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    // -------------------------------\n    //   Common internal functions\n    // -------------------------------\n\n    /**\n     * @dev Pulls `amount` of `token` from `user` into this contract.\n     *      For ERC20: enforces `_msgSender() == user` (caller must have routed through `AllowanceHolder.exec`) and calls AH.transferFrom via assembly.\n     *      AH selector: transferFrom(address,address,address,uint256) = 0x15dacbea.\n     *      For native ETH: ETH must already be present as msg.value; verify sufficient value was forwarded.\n     * @param token Input token or `CurrencyLib.NATIVE_TOKEN_ADDRESS`.\n     * @param user Owner whose AllowanceHolder-scoped allowance is consumed.\n     * @param amount Tokens or wei to pull.\n     */\n    function _pullFromUser(address token, address user, uint256 amount) internal {\n        // Check input value if native token\n        if (token == CurrencyLib.NATIVE_TOKEN_ADDRESS) {\n            if (msg.value < amount) {\n                revert InsufficientMsgValue();\n            }\n            return;\n        }\n\n        // Check caller is user\n        if (_msgSender() != user) revert CallerNotSignedUser();\n\n        // Call AllowanceHolder.transferFrom()\n        address allowanceHolder = address(ALLOWANCE_HOLDER);\n        assembly (\"memory-safe\") {\n            // Manually ABI-encode AllowanceHolder.transferFrom(address token, address owner, address recipient, uint256 amount)\n            // selector 0x15dacbea. Calldata is 0x84 (132) bytes and starts at ptr+0x1c (see last mstore below).\n            //\n            // The `shl(0x60, addr)` trick left-aligns a 20-byte address in a 32-byte word: the high 20 bytes\n            // hold the address and the trailing 12 bytes are zero, which simultaneously encodes the address AND\n            // provides the ABI zero-padding for the *next* field — so each shifted mstore clears the following\n            // field's padding without a separate write.\n            //\n            // Calldata layout relative to ptr+0x1c:\n            //   [0..3]    selector   (0x15dacbea)\n            //   [4..35]   token      (12-byte pad + 20-byte address)\n            //   [36..67]  owner/user (12-byte pad + 20-byte address)\n            //   [68..99]  recipient  (12-byte pad + 20-byte address = address(this))\n            //   [100..131] amount    (uint256)\n            let ptr := mload(0x40)\n            mstore(add(0x80, ptr), amount) // calldata[100..131]: amount (uint256, right-aligned)\n            mstore(add(0x60, ptr), address()) // calldata[68..99]: recipient = this contract (right-aligned, high 12 bytes are zero padding)\n            mstore(add(0x4c, ptr), shl(0x60, user)) // calldata[48..67]: user address; trailing 12 zero bytes fill calldata[68..79] (recipient padding)\n            // `shl(0x60)` (96-bit), NOT `shl(0xa0)` (160-bit): 0xa0 here is literal 160, which\n            // shifts the 20-byte address out of place and corrupts the calldata token. Same as 0x-settler `Permit2Payment._allowanceHolderTransferFrom`.\n            mstore(add(0x2c, ptr), shl(0x60, token)) // calldata[16..35]: token address; trailing 12 zero bytes fill calldata[36..47] (user padding)\n            mstore(add(0x0c, ptr), 0x15dacbea000000000000000000000000) // selector at calldata[0..3]; 12 zero bytes fill calldata[4..15] (token padding); calldata begins at ptr+0x1c\n\n            if iszero(call(gas(), allowanceHolder, 0x00, add(0x1c, ptr), 0x84, 0x00, 0x00)) {\n                // if call did not succeed, revert with the revert returndata\n                let p := mload(0x40)\n                returndatacopy(p, 0x00, returndatasize())\n                revert(p, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev Executes the swap call and returns the output amount.\n     *      `useBalanceOf=true`: measure output as (balance after − balance before) at `outputReceiver`.\n     *      `useBalanceOf=false`: decode output from returndata at `swapData.returnDataWordOffset`.\n     *      `outputReceiver` must be `address(this)` when tokens are expected at the contract (post-swap fee path, bridge path)\n     *      or the end user when the router sends directly to them.\n     * @param swapData Swap target, value, output token, and returndata layout.\n     * @param swapCallData Calldata forwarded to `swapData.target`.\n     * @param useBalanceOf When true, use balance delta instead of returndata decoding.\n     * @param outputReceiver Account whose output-token balance is measured or credited.\n     * @return finalAmount Gross swap output amount.\n     */\n    function _execSwap(\n        SwapData calldata swapData,\n        bytes calldata swapCallData,\n        bool useBalanceOf,\n        address outputReceiver\n    ) internal returns (uint256 finalAmount) {\n        if (useBalanceOf) {\n            // Measure output as (balance after − balance before) at `outputReceiver`\n            uint256 before = CurrencyLib.balanceOf(swapData.outputToken, outputReceiver);\n            _execCallCalldata(swapData.target, swapData.value, swapCallData, false);\n            finalAmount = CurrencyLib.balanceOf(swapData.outputToken, outputReceiver) - before;\n        } else {\n            // Decode output from returndata\n            bytes memory ret = _execCallCalldata(swapData.target, swapData.value, swapCallData, true);\n            finalAmount = _decodeReturnWord(ret, swapData.returnDataWordOffset);\n        }\n    }\n\n    /**\n     * @dev Low-level `call` with bubbled revert data on failure.\n     * @param target Call recipient.\n     * @param value Wei forwarded with the call.\n     * @param data ABI-encoded calldata in memory.\n     */\n    function _execCall(address target, uint256 value, bytes memory data) internal {\n        bool success;\n        assembly (\"memory-safe\") {\n            success := call(gas(), target, value, add(data, 0x20), mload(data), 0, 0)\n        }\n\n        if (!success) {\n            bytes memory ret;\n            assembly (\"memory-safe\") {\n                // prep and return revert data\n                let returnDataSize := returndatasize()\n                ret := mload(0x40)\n                mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // bump free pointer\n                revert(add(ret, 0x20), mload(ret)) // bubbles up the original revert payload\n            }\n        }\n    }\n\n    /**\n     * @dev Low-level `call` using calldata copied to memory; optionally captures returndata.\n     * @dev Helps cheaper external calls avoiding early copy of calldata to memory.\n     * @param target Call recipient.\n     * @param value Wei forwarded with the call.\n     * @param data Calldata slice forwarded to `target`.\n     * @param storeResult When true, copy returndata into memory even on success.\n     * @return ret Returndata when `storeResult` is true or the call reverts (revert bubbles).\n     */\n    function _execCallCalldata(address target, uint256 value, bytes calldata data, bool storeResult)\n        internal\n        returns (bytes memory ret)\n    {\n        bool success;\n        assembly (\"memory-safe\") {\n            let ptr := mload(0x40)\n            calldatacopy(ptr, data.offset, data.length) // copy calldata slice to fresh memory (avoids redundant memory alloc)\n            mstore(0x40, and(add(add(ptr, data.length), 0x1f), not(0x1f))) // advance free pointer to next 32-byte boundary\n            success := call(gas(), target, value, ptr, data.length, 0, 0)\n        }\n\n        if (!success || storeResult) {\n            assembly (\"memory-safe\") {\n                // prep and return revert data\n                let returnDataSize := returndatasize()\n                ret := mload(0x40)\n                mstore(ret, returnDataSize) // write length prefix on free-mem pointer\n                returndatacopy(add(ret, 0x20), 0, returnDataSize) // copy returndata after length\n                mstore(0x40, and(add(add(add(ret, 0x20), returnDataSize), 0x1f), not(0x1f))) // bump free pointer\n            }\n            if (!success) {\n                assembly (\"memory-safe\") {\n                    revert(add(ret, 0x20), mload(ret)) // bubble up the raw revert payload\n                }\n            }\n        }\n    }\n\n    /**\n     * @dev Reads the 32-byte word at `wordOffset` from ABI-encoded `ret` (word index, not byte offset).\n     * @param ret Return blob from a prior call.\n     * @param wordOffset Zero-based index of the 32-byte word to load.\n     * @return word Decoded amount or value at that offset.\n     */\n    function _decodeReturnWord(bytes memory ret, uint256 wordOffset) internal pure returns (uint256 word) {\n        uint256 offset = wordOffset * 32;\n        if (offset + 32 > ret.length) revert ReturnDataOutOfBounds();\n\n        assembly (\"memory-safe\") {\n            // read the word at the offset from return data\n            word := mload(add(add(ret, 0x20), offset))\n        }\n    }\n}\n"},"src/common/lib/CurrencyLib.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nerror TransferFailed();\n\n// @audit Audited before by Hexens: https://github.com/SocketDotTech/audits/blob/main/Bungee/12-2024%20-%20Bungee%20Protocol%20-%20Hexens.pdf\n/// @title CurrencyLib\n/// @notice Token transfer + balance helpers that treat the canonical native\n///         pseudo-token (`0xEee...EEe`) the same way as the marketplace's\n///         CurrencyLib. Backed by Solady SafeTransferLib for ERC20.\nlibrary CurrencyLib {\n    /// @dev address used to identify native token\n    address internal constant NATIVE_TOKEN_ADDRESS = address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);\n\n    function balanceOf(address token, address addr) internal view returns (uint256 balance) {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            balance = addr.balance;\n        } else {\n            balance = SafeTransferLib.balanceOf(token, addr);\n        }\n    }\n\n    function transferFrom(address token, address from, address recipient, uint256 amount) internal {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            _transferNative(recipient, amount);\n        } else {\n            SafeTransferLib.safeTransferFrom(token, from, recipient, amount);\n        }\n    }\n\n    function transfer(address token, address recipient, uint256 amount) internal {\n        if (token == NATIVE_TOKEN_ADDRESS) {\n            _transferNative(recipient, amount);\n        } else {\n            SafeTransferLib.safeTransfer(token, recipient, amount);\n        }\n    }\n\n    function _transferNative(address recipient, uint256 amount) private {\n        (bool success,) = recipient.call{value: amount, gas: 27_000}(\"\");\n        if (!success) {\n            revert TransferFailed();\n        }\n    }\n}\n"},"src/common/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\ninterface IERC20 {\n    function allowance(address owner, address spender) external view returns (uint256);\n}\n"},"src/common/lib/BytesSpliceLib.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity 0.8.34;\n\n/// @title BytesSpliceLib\n/// @notice Generalisation of the in-place calldata patching. Supports patching\n///         either a single 32-byte word (for `uint256` amount fields) or an\n///         arbitrary length copy from one bytes blob to another.\nlibrary BytesSpliceLib {\n    error SpliceLengthZero();\n    error SpliceSrcOutOfBounds();\n    error SpliceDstOutOfBounds();\n    error SplicePositionOutOfBounds();\n\n    /// @notice Overwrites a 32-byte word at `position` in `data` with `word`.\n    function spliceWord(bytes memory data, uint256 position, uint256 word) internal pure {\n        // Bounds check: position + 32 must fit in data\n        if (position + 32 > data.length) {\n            revert SplicePositionOutOfBounds();\n        }\n        // in-place mstore at data + 32 (skip length prefix) + position\n        assembly (\"memory-safe\") {\n            mstore(add(add(data, 0x20), position), word)\n        }\n    }\n\n    /// @notice Overwrites a 32-byte word at every entry in `positions`.\n    function spliceWords(bytes memory data, uint256[] memory positions, uint256 word) internal pure {\n        uint256 len = positions.length;\n        for (uint256 i = 0; i < len;) {\n            spliceWord({data: data, position: positions[i], word: word});\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    /// @notice Copies `length` bytes from `src` at `srcOffset` into `dst` at `dstOffset`.\n    /// @dev Uses Cancun's `mcopy`. Performs bounds checks on both blobs and\n    ///      rejects zero-length splices to match the safety expectations on\n    ///      the modular OpenRouter actions.\n    function spliceBytes(bytes memory dst, uint256 dstOffset, bytes memory src, uint256 srcOffset, uint256 length)\n        internal\n        pure\n    {\n        if (length == 0) {\n            revert SpliceLengthZero();\n        }\n        // unchecked: revert paths use checked add to keep things readable.\n        if (srcOffset + length > src.length) {\n            revert SpliceSrcOutOfBounds();\n        }\n        if (dstOffset + length > dst.length) {\n            revert SpliceDstOutOfBounds();\n        }\n        assembly (\"memory-safe\") {\n            mcopy(add(add(dst, 0x20), dstOffset), add(add(src, 0x20), srcOffset), length)\n        }\n    }\n}\n"},"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)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @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 :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev 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 :=\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            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)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(\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                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), 0xa0, 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"},"src/common/interfaces/IAllowanceHolder.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.34;\n\n// @dev Socket CREATE3 AllowanceHolder address. Chain-specific OpenRouter builds\n//      patch this constant before compilation when needed.\nIAllowanceHolder constant ALLOWANCE_HOLDER = IAllowanceHolder(0x50c4E75a512F2A14A7b304787Adf79C4531A5909);\n\n/// @title IAllowanceHolder\n/// @notice External-facing interface of 0x's AllowanceHolder contract.\n///         Mirrors `0x-settler/src/allowanceholder/IAllowanceHolder.sol`.\ninterface IAllowanceHolder {\n    /// @notice The user calls `exec(operator, token, amount, target, data)` on\n    ///         AllowanceHolder. AllowanceHolder writes a transient allowance for\n    ///         `(operator, msgSender, token)` of `amount`, then calls `target`\n    ///         with `data` and the user's address appended ERC-2771-style.\n    function exec(address operator, address token, uint256 amount, address payable target, bytes calldata data)\n        external\n        payable\n        returns (bytes memory result);\n\n    /// @notice Counterpart to `exec`. Called by `operator` (the OpenRouter)\n    ///         to consume the transient allowance and pull `amount` of\n    ///         `token` from `owner` to `recipient`.\n    function transferFrom(address token, address owner, address recipient, uint256 amount) external returns (bool);\n}\n"},"src/common/allowance/AllowanceHolderContext.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity 0.8.34;\n\nimport {ALLOWANCE_HOLDER} from \"../interfaces/IAllowanceHolder.sol\";\n\n/// @title AllowanceHolderContext\n/// @notice Self-contained port of 0x-settler's AllowanceHolderContext. Provides\n///         `_msgSender()` that returns the original user when this contract is\n///         called via `AllowanceHolder.exec(...)` (which appends the user's\n///         address as the last 20 bytes of calldata, ERC-2771 style).\n///         Also exposes the dummy `balanceOf(address)` so AllowanceHolder's\n///         confused-deputy probe (it tries to call `balanceOf` on the target\n///         to detect whether `target` looks like an ERC20) does not reject the\n///         call.\nabstract contract AllowanceHolderContext {\n    /// @notice Returns the effective msg.sender. When the immediate caller is\n    ///         `AllowanceHolder`, the trusted forwarder, the real user is\n    ///         decoded from the last 20 bytes of calldata.\n    function _msgSender() internal view virtual returns (address sender) {\n        sender = msg.sender;\n        if (sender == address(ALLOWANCE_HOLDER)) {\n            // ERC-2771 style: AllowanceHolder appends the user's address as\n            // the trailing 20 bytes of calldata after invoking target.\n            assembly (\"memory-safe\") {\n                sender := shr(0x60, calldataload(sub(calldatasize(), 0x14)))\n            }\n        }\n    }\n\n    /// @notice True if the call was forwarded by AllowanceHolder.\n    function _isForwarded() internal view virtual returns (bool) {\n        return msg.sender == address(ALLOWANCE_HOLDER);\n    }\n\n    /// @notice msg.data with the trailing 20-byte user address stripped when\n    ///         the call was forwarded by AllowanceHolder.\n    function _msgData() internal view virtual returns (bytes calldata) {\n        if (msg.sender == address(ALLOWANCE_HOLDER)) {\n            return msg.data[:msg.data.length - 20];\n        }\n        return msg.data;\n    }\n\n    /// @notice Dummy `balanceOf` implementation. AllowanceHolder probes its\n    ///         `target` with `IERC20.balanceOf(...)` and reverts if the call\n    ///         returns 32 bytes (i.e. target looks like an ERC20). We return\n    ///         a single-byte return so the check passes, mirroring 0x-settler.\n    function balanceOf(address) external pure {\n        assembly (\"memory-safe\") {\n            mstore8(0x00, 0x00)\n            return(0x00, 0x01)\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"libraries":{},"optimizer":{"runs":2000,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"src/OpenRouter.sol":{"id":1},"src/common/lib/CurrencyLib.sol":{"id":6},"src/common/interfaces/IERC20.sol":{"id":4},"src/common/lib/BytesSpliceLib.sol":{"id":5},"solady/src/utils/SafeTransferLib.sol":{"id":0},"src/common/interfaces/IAllowanceHolder.sol":{"id":3},"src/common/allowance/AllowanceHolderContext.sol":{"id":2}},"contracts":{"src/OpenRouter.sol":{"OpenRouter":{"abi":[{"name":"CallFailed","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"returndata","type":"bytes","internalType":"bytes"}]},{"name":"CallerNotSignedUser","type":"error","inputs":[]},{"name":"FutureSplice","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"sourceActionIndex","type":"uint256","internalType":"uint256"}]},{"name":"InsufficientMsgValue","type":"error","inputs":[]},{"name":"MissingNativeValue","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"}]},{"name":"ReturnDataOutOfBounds","type":"error","inputs":[]},{"name":"SpliceOutOfBounds","type":"error","inputs":[{"name":"actionIndex","type":"uint256","internalType":"uint256"},{"name":"spliceIndex","type":"uint256","internalType":"uint256"}]},{"name":"SplicePositionOutOfBounds","type":"error","inputs":[]},{"name":"SwapOutputInsufficient","type":"error","inputs":[]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"RequestExecuted","type":"event","inputs":[{"name":"quoteId","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"balanceOf","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"pure"},{"name":"bridge","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"bridgeData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.BridgeData"},{"name":"bridgeCallData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"performActions","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"actions","type":"tuple[]","components":[{"name":"actionInfo","type":"uint256","internalType":"uint256"},{"name":"data","type":"bytes","internalType":"bytes"},{"name":"splices","type":"uint256[]","internalType":"uint256[]"}],"internalType":"struct OpenRouter.Action[]"}],"outputs":[],"stateMutability":"payable"},{"name":"swap","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"flags","type":"uint256","internalType":"uint256"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"swapData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"outputToken","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"minOutput","type":"uint256","internalType":"uint256"},{"name":"returnDataWordOffset","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.SwapData"},{"name":"swapCallData","type":"bytes","internalType":"bytes"},{"name":"receiver","type":"address","internalType":"address"}],"outputs":[{"name":"finalAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"swapAndBridge","type":"function","inputs":[{"name":"quoteId","type":"bytes32","internalType":"bytes32"},{"name":"flags","type":"uint256","internalType":"uint256"},{"name":"input","type":"tuple","components":[{"name":"user","type":"address","internalType":"address"},{"name":"inputToken","type":"address","internalType":"address"},{"name":"inputAmount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.InputData"},{"name":"fee","type":"tuple","components":[{"name":"receiver","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.FeeData"},{"name":"swapData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"outputToken","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"minOutput","type":"uint256","internalType":"uint256"},{"name":"returnDataWordOffset","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.SwapData"},{"name":"swapCallData","type":"bytes","internalType":"bytes"},{"name":"bridgeData","type":"tuple","components":[{"name":"target","type":"address","internalType":"address"},{"name":"approvalSpender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"}],"internalType":"struct OpenRouter.BridgeData"},{"name":"bridgeCallData","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.34+commit.80d5c536\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"actionIndex\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"returndata\",\"type\":\"bytes\"}],\"name\":\"CallFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CallerNotSignedUser\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"actionIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"sourceActionIndex\",\"type\":\"uint256\"}],\"name\":\"FutureSplice\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientMsgValue\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"actionIndex\",\"type\":\"uint256\"}],\"name\":\"MissingNativeValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReturnDataOutOfBounds\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"actionIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"spliceIndex\",\"type\":\"uint256\"}],\"name\":\"SpliceOutOfBounds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SplicePositionOutOfBounds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapOutputInsufficient\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"quoteId\",\"type\":\"bytes32\"}],\"name\":\"RequestExecuted\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"quoteId\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"inputToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"inputAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.InputData\",\"name\":\"input\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.FeeData\",\"name\":\"fee\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"approvalSpender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.BridgeData\",\"name\":\"bridgeData\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"bridgeCallData\",\"type\":\"bytes\"}],\"name\":\"bridge\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"quoteId\",\"type\":\"bytes32\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"actionInfo\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"splices\",\"type\":\"uint256[]\"}],\"internalType\":\"struct OpenRouter.Action[]\",\"name\":\"actions\",\"type\":\"tuple[]\"}],\"name\":\"performActions\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"quoteId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"flags\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"inputToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"inputAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.InputData\",\"name\":\"input\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.FeeData\",\"name\":\"fee\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"approvalSpender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"outputToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minOutput\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"returnDataWordOffset\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.SwapData\",\"name\":\"swapData\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"swapCallData\",\"type\":\"bytes\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"swap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"finalAmount\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"quoteId\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"flags\",\"type\":\"uint256\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"inputToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"inputAmount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.InputData\",\"name\":\"input\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.FeeData\",\"name\":\"fee\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"approvalSpender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"outputToken\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minOutput\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"returnDataWordOffset\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.SwapData\",\"name\":\"swapData\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"swapCallData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"approvalSpender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"internalType\":\"struct OpenRouter.BridgeData\",\"name\":\"bridgeData\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"bridgeCallData\",\"type\":\"bytes\"}],\"name\":\"swapAndBridge\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)\":{\"details\":\"Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`.\",\"params\":{\"bridgeCallData\":\"Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller).\",\"bridgeData\":\"Bridge target, approval spender, and `msg.value` for the bridge call.\",\"fee\":\"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\",\"input\":\"User, input token, and pull amount.\",\"quoteId\":\"Caller-defined correlation id logged in `RequestExecuted`.\"}},\"performActions(bytes32,(uint256,bytes,uint256[])[])\":{\"params\":{\"actions\":\"Ordered actions; each may splice bytes from a prior action's returndata into its calldata.\",\"quoteId\":\"Caller-defined correlation id logged in `RequestExecuted`.\"}},\"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)\":{\"details\":\"For pre-fee / no-fee: the swap router must      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.`minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.\",\"params\":{\"fee\":\"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\",\"flags\":\"Packed flags\",\"input\":\"User, input token, and pull amount.\",\"quoteId\":\"Caller-defined correlation id logged in `RequestExecuted`.\",\"receiver\":\"Address that ultimately receives the swap output (net of any post-swap fee).\",\"swapCallData\":\"Calldata forwarded to `swapData.target`.\",\"swapData\":\"Swap target, spender, output token, value, `minOutput`, and returndata offset.\"},\"returns\":{\"finalAmount\":\"Gross swap output sent to receiver after any post-swap fee\"}},\"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)\":{\"details\":\"Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies.\",\"params\":{\"bridgeCallData\":\"Bridge calldata; optionally spliced with swap output per `flags`.\",\"bridgeData\":\"Bridge target, approval spender, and static `msg.value` addend.\",\"fee\":\"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.\",\"flags\":\"Packed flags\",\"input\":\"User, input token, and pull amount.\",\"quoteId\":\"Caller-defined correlation id logged in `RequestExecuted`.\",\"swapCallData\":\"Calldata forwarded to `swapData.target`.\",\"swapData\":\"Swap target, spender, output token, value, `minOutput`, and returndata offset.\"}}},\"stateVariables\":{\"BALANCE_FLAG_BIT_MASK\":{\"details\":\"Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word.\"},\"BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK\":{\"details\":\"Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags.\"},\"BRIDGE_AMOUNT_POSITION_MASK\":{\"details\":\"Mask for the packed uint16 bridge amount position after shifting.\"},\"BRIDGE_AMOUNT_POSITION_SHIFT\":{\"details\":\"Shift for the packed uint16 bridge amount position.\"},\"BRIDGE_VALUE_FLAG_BIT_MASK\":{\"details\":\"Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee).\"},\"POST_FEE_FLAG_BIT_MASK\":{\"details\":\"Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token.\"}},\"title\":\"OpenRouter\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"balanceOf(address)\":{\"notice\":\"Dummy `balanceOf` implementation. AllowanceHolder probes its         `target` with `IERC20.balanceOf(...)` and reverts if the call         returns 32 bytes (i.e. target looks like an ERC20). We return         a single-byte return so the check passes, mirroring 0x-settler.\"},\"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)\":{\"notice\":\"Perform bridge with optional pre-bridge fee.\"},\"performActions(bytes32,(uint256,bytes,uint256[])[])\":{\"notice\":\"Runs a sequence of generic actions with optional returndata splicing between steps.\"},\"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)\":{\"notice\":\"Perform swap with optional pre/post fee.\"},\"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)\":{\"notice\":\"Perform swap and bridge with optional pre/post swap fee.\"}},\"notice\":\"Pull → optional fee → swap/bridge execution without backend signature verification.         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OpenRouter.sol\":\"OpenRouter\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":2000},\"remappings\":[]},\"sources\":{\"solady/src/utils/SafeTransferLib.sol\":{\"keccak256\":\"0xf53a25143307304d9de7186f93f11faae3cc4f722c4b088aed6f4f8f87a02f7a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b722c08826ece540bbc4ee9f825aac501282c0900a0a2caa618154d77f23223d\",\"dweb:/ipfs/QmeMsPT5S4vV8f7DYC2eZ7TBCrtRi9cKMsoW6Ca62Uaqwg\"]},\"src/OpenRouter.sol\":{\"keccak256\":\"0x8e3f06d3c7053073d83a90fbdedc239549432b263fce4397b701e34b65a64087\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://99bb7e565a541f573c6fa2e7b9c7b8fe82138f34768976c071bf9aa026f197f3\",\"dweb:/ipfs/QmcLkmuV6opYvujrJVboyXFDhp8rhWLfq5SBdHRmVjk5dv\"]},\"src/common/allowance/AllowanceHolderContext.sol\":{\"keccak256\":\"0x8c130745dab83f225e99a460a89851bf48682838b0e3d18f409739725ac6bd8e\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0437ebb237c1908a2fb08e59373c2d7568d1a028447a97ded90fda0e585cf556\",\"dweb:/ipfs/QmcZtjSCA9qh7Cp7tPjhkffi5GSXK7hpFUqAHSzjcYmvvN\"]},\"src/common/interfaces/IAllowanceHolder.sol\":{\"keccak256\":\"0xaf50059c4806dafab15974253cbb5296170f3f55a40de65da9768f8ce4d3da82\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1eaa1aa4c54a003aa0fdec0cf60bbad1bfd508ca972c07fefc8c401d9792c5c4\",\"dweb:/ipfs/QmXb4HrqRSEYrkDBVqAxJJCAGmm5wFirDqwkyvECneTxdb\"]},\"src/common/interfaces/IERC20.sol\":{\"keccak256\":\"0xaf6861d9a1d139fe78365e8c757f1cdd7b6bfcb44390109d57921b6bce83f69a\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://8c2a5a735ba8e3a23f669010239fca5316f04c97ca688b4556385ca6224c773c\",\"dweb:/ipfs/QmSAbGA8QegmTUgWouSexifn8a2wstwztpF4dxcaJZcZBt\"]},\"src/common/lib/BytesSpliceLib.sol\":{\"keccak256\":\"0x939e73d55bfb6e4d2ff85fc569579e6936fd8108ace3b41e4d62bb4e913fb561\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://55d40e31397f3eaddecf0863b909f8b964f94c3387aeae58a533e305ae704cad\",\"dweb:/ipfs/QmTEiokk9ECDSH8BBvPBun8ELwahNNfhCR9NREYuNFY998\"]},\"src/common/lib/CurrencyLib.sol\":{\"keccak256\":\"0x6b19af1e8e4f383d9096af17e187c7b9d7e6b56d418d0c0f5acf73b7661f4f45\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://4066f96169d3117122eb7804bf717d4b333202bc26042ce2d427a8f0c135ea5f\",\"dweb:/ipfs/QmPmh2HHZKXQWJWfzcsV9f48F2VqW5Y4g8MXCwYxCScgvy\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Pull → optional fee → swap/bridge execution without backend signature verification.         Fund safety rests on AllowanceHolder's transient allowance scoping (operator + owner + token):         only the user whose address was passed to `AllowanceHolder.exec` can authorise a pull of         their own funds. The `_msgSender() == user` check in `_pullFromUser` enforces this.","methods":{"balanceOf(address)":{"notice":"Dummy `balanceOf` implementation. AllowanceHolder probes its         `target` with `IERC20.balanceOf(...)` and reverts if the call         returns 32 bytes (i.e. target looks like an ERC20). We return         a single-byte return so the check passes, mirroring 0x-settler."},"performActions(bytes32,(uint256,bytes,uint256[])[])":{"notice":"Runs a sequence of generic actions with optional returndata splicing between steps."},"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"notice":"Perform bridge with optional pre-bridge fee."},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"notice":"Perform swap with optional pre/post fee."},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"notice":"Perform swap and bridge with optional pre/post swap fee."}},"version":1},"devdoc":{"kind":"dev","title":"OpenRouter","methods":{"performActions(bytes32,(uint256,bytes,uint256[])[])":{"params":{"actions":"Ordered actions; each may splice bytes from a prior action's returndata into its calldata.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`."}},"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","bridgeData":"Bridge target, approval spender, and `msg.value` for the bridge call.","bridgeCallData":"Calldata forwarded to `bridgeData.target` (amount must be baked in by the caller)."},"details":"Because no swap is involved, `finalAmount = inputAmount - feeAmount` is fully knowable by the caller before signing.      The caller must therefore bake the correct amount directly into `bridgeCallData` and set `bridgeData.value` to the desired `msg.value` for the bridge call.      No runtime calldata splicing is performed. The caller MUST route through `AllowanceHolder.exec` for ERC-20 inputs so that `_msgSender()` resolves to `input.user`."},"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","receiver":"Address that ultimately receives the swap output (net of any post-swap fee).","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset.","swapCallData":"Calldata forwarded to `swapData.target`."},"details":"For pre-fee / no-fee: the swap router must      be instructed (via `swapCallData`) to send tokens directly to `receiver`; the contract never holds the output.      For post-fee: tokens land at this contract, fee is deducted, net is forwarded to `receiver`.`minOutput` is the minimum gross amount coming out of the swap (before any output-token fee). It is enforced immediately after `_execSwap`, then post-swap fee (if any) is collected.      Pre-fee paths take the input-side fee before the swap; `minOutput` still guards the swap outcome.","returns":{"finalAmount":"Gross swap output sent to receiver after any post-swap fee"}},"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)":{"params":{"fee":"Fee collection info: receiver and amount. Set `amount` to 0 to skip fee collection.","flags":"Packed flags","input":"User, input token, and pull amount.","quoteId":"Caller-defined correlation id logged in `RequestExecuted`.","swapData":"Swap target, spender, output token, value, `minOutput`, and returndata offset.","bridgeData":"Bridge target, approval spender, and static `msg.value` addend.","swapCallData":"Calldata forwarded to `swapData.target`.","bridgeCallData":"Bridge calldata; optionally spliced with swap output per `flags`."},"details":"Same `minOutput` rule as `swap`: validated on gross `_execSwap` output, then optional output fee applies."}},"version":1,"stateVariables":{"BALANCE_FLAG_BIT_MASK":{"details":"Bit mask 0x02: measure swap output by balance delta when `(flags & mask) != 0`; clear = returndata word."},"POST_FEE_FLAG_BIT_MASK":{"details":"Bit mask 0x01: post-swap fee path when `(flags & mask) != 0`; clear = pre-swap fee from input token."},"BRIDGE_VALUE_FLAG_BIT_MASK":{"details":"Bit mask 0x04: `finalAmount + bridge.value` is forwarded as msg.value (bridge.value acts as a static addend, e.g. LZ nativeFee)."},"BRIDGE_AMOUNT_POSITION_MASK":{"details":"Mask for the packed uint16 bridge amount position after shifting."},"BRIDGE_AMOUNT_POSITION_SHIFT":{"details":"Shift for the packed uint16 bridge amount position."},"BRIDGE_AMOUNT_POSITION_FLAG_BIT_MASK":{"details":"Bit mask 0x08: splice finalAmount into bridge calldata at the uint16 position packed in flags."}}},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"902:35395:1:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"902:35395:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17231:166;;;;;;:::i;:::-;;:::i;:::-;;10577:2577;;;;;;:::i;:::-;;:::i;:::-;;;3059:25:7;;;3047:2;3032:18;10577:2577:1;;;;;;;13992:605;;;;;;:::i;:::-;;:::i;2304:157:2:-;;;;;;;;;;-1:-1:-1;2304:157:2;;;;;:::i;:::-;;:::i;15597:1319:1:-;;;;;;:::i;:::-;;:::i;17231:166::-;17326:24;17342:7;;17326:15;:24::i;:::-;17366;;17382:7;;17366:24;;;;;17231:166;;;:::o;10577:2577::-;10834:19;;10903:10;;;;:15;;;;:58;;-1:-1:-1;7335:4:1;10924:30;;10923:37;;10903:58;10888:73;-1:-1:-1;7514:4:1;10993:29;;10992:36;;11110:62;11124:16;;;;;;;;:::i;:::-;11142:10;;;;:5;:10;:::i;:::-;11154:5;:17;;;11110:13;:62::i;:::-;11243:17;;;;11278:10;;;;:15;;;;:27;;;11298:7;11297:8;11278:27;11274:267;;;11345:10;;;;;;11373:63;;11394:16;;;;;;;;;:::i;:::-;11412:12;;;;:3;:12;:::i;:::-;11426:9;11373:20;:63::i;:::-;11486:22;;11274:267;11684:1;11648:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11648:38:1;;;:94;;;;-1:-1:-1;682:42:6;11690:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11690:52:1;;;11648:94;:253;;;;-1:-1:-1;11833:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;11826:34:1;;11869:4;11876:24;;;;;;;;:::i;:::-;11826:75;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;11826:75:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;11826:75:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11814:9;:87;11648:253;11586:503;;;11975:99;12012:16;;;;;;;;:::i;:::-;12030:24;;;;;;;;:::i;:::-;-1:-1:-1;;11975:36:1;:99::i;:::-;11040:1059;12344:22;12369:7;:34;;12395:8;12369:34;;;12387:4;12369:34;12344:59;;12452:63;12462:8;12472:12;;12486;12500:14;12452:9;:63::i;:::-;12438:77;;12543:8;:18;;;12529:11;:32;12525:69;;;12570:24;;;;;;;;;;;;;;12525:69;12609:7;12605:393;;;12689:10;;;;12713:67;12734:20;;;;;;;;:::i;12713:67::-;12822:24;;;;;12922:65;12943:20;;;;;;;;:::i;:::-;12965:8;12975:11;12922:20;:65::i;:::-;12618:380;12605:393;13123:24;;13139:7;;13123:24;;;;;10855:2299;;;10577:2577;;;;;;;;;;:::o;13992:605::-;14350:19;14372:60;14390:5;14397;14404:3;14409:8;14419:12;;14372:17;:60::i;:::-;14350:82;-1:-1:-1;14469:81:1;14481:20;;;;;;;;:::i;:::-;14503:11;14516:5;14523:10;14535:14;;14469:11;:81::i;:::-;14566:24;;14582:7;;14566:24;;;;;14302:295;13992:605;;;;;;;;;;:::o;2304:157:2:-;2409:4;;2395:19;2440:4;2409;2427:18;15597:1319:1;15866:62;15880:16;;;;;;;;:::i;:::-;15898:10;;;;:5;:10;:::i;:::-;15910:5;:17;;;15866:13;:62::i;:::-;15993:10;;;;16017:14;;16013:108;;16047:63;16068:16;;;;;;;;:::i;:::-;16086:12;;;;:3;:12;:::i;16047:63::-;16194:17;;;;;:29;;;;16131:17;;16333:26;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16333:40:1;;;:96;;;;-1:-1:-1;682:42:6;16377:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16377:52:1;;;16333:96;:249;;;;-1:-1:-1;16512:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;16505:34:1;;16548:4;16555:26;;;;;;;;:::i;:::-;16505:77;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;16505:77:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;16505:77:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;16493:9;:89;16333:249;16278:478;;;16644:101;16681:16;;;;;;;;:::i;:::-;16699:26;;;;;;;;:::i;16644:101::-;16792:77;16810:17;;;;:10;:17;:::i;:::-;16829:10;:16;;;16847:14;;16863:5;16792:17;:77::i;:::-;-1:-1:-1;16885:24:1;;16901:7;;16885:24;;;;;15804:1112;;15597:1319;;;;;;:::o;22707:4547::-;22802:7;22778:21;22802:7;22851:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22826:51;;22893:9;22888:4360;22908:13;22904:1;:17;22888:4360;;;22938:22;22963:7;;22971:1;22963:10;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;22938:35;-1:-1:-1;22987:21:1;23011:11;;;;22938:35;23011:11;:::i;:::-;22987:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22987:35:1;;-1:-1:-1;23131:14:1;;-1:-1:-1;;;23131:14:1;;;;;:::i;:::-;:21;;23107:45;;23171:9;23166:1308;23186:13;23182:1;:17;23166:1308;;;23220:18;23241:14;;;;:6;:14;:::i;:::-;23256:1;23241:17;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;23276:46:1;;;23413:22;;;23409:69;;23444:34;;;;;;;;8342:25:7;;;8383:18;;;8376:34;;;8315:18;;23444:34:1;;;;;;;;23409:69;23892:26;;23497:44;23538:2;23524:16;;;23497:44;;;23652:3;23638:17;;;23611:45;;;;23758:3;23744:17;;;;23497;;23892:7;;23900:17;;23892:26;;;;;;:::i;:::-;;;;;;;23870:48;;23961:6;:13;23952:6;23940:9;:18;;;;:::i;:::-;:34;:74;;;-1:-1:-1;23999:15:1;;23978:18;23990:6;23978:9;:18;:::i;:::-;:36;23940:74;23936:151;;;24045:23;;;;;;;;8342:25:7;;;8383:18;;;8376:34;;;8315:18;;24045:23:1;8168:248:7;23936:151:1;24363:6;24351:9;24344:4;24336:6;24332:17;24328:33;24316:9;24309:4;24299:8;24295:19;24291:35;24285:85;24438:3;;;;;23202:1272;;;;;;23166:1308;;;-1:-1:-1;24520:12:1;24567:17;;24631:6;24618:19;;24617:26;;24725:4;24712:17;;24822:2;24808:16;;;24893:19;24873:8;:40;24869:1277;;25131:1;25128;25117:8;25111:15;25104:4;25094:8;25090:19;25082:6;25075:5;25064:69;25053:80;;24869:1277;;;25195:25;25175:8;:46;25171:975;;25263:2;25245:8;:15;:20;25241:54;;;25274:21;;;;;;;;3059:25:7;;;3032:18;;25274:21:1;2913:177:7;25241:54:1;25313:17;25348:21;25390:2;25372:8;:15;:20;;;;:::i;:::-;25348:44;;25586:4;25576:8;25572:19;25566:26;25553:39;;25780:1;25777;25762:13;25755:4;25745:8;25741:19;25730:9;25722:6;25715:5;25710:72;25699:83;;25435:416;;25171:975;;;26112:1;26109;26098:8;26092:15;26085:4;26075:8;26071:19;26068:1;26060:6;26053:5;26048:66;26037:77;;25171:975;26260:7;26259:8;:23;;;;26271:11;26259:23;26255:924;;;26504:4;26498:11;26454:16;26530:27;;;26454:16;26652:1;26645:4;26636:14;;26621:49;26740:46;26744:35;;;26740:46;-1:-1:-1;;26736:62:1;26730:4;26723:76;27021:7;27016:39;;27048:1;27051:3;27037:18;;;;;;;;;;;;:::i;27016:39::-;27161:3;27148:7;27156:1;27148:10;;;;;;;;:::i;:::-;;;;;;:16;;;;26284:895;26255:924;27220:3;;;;;22924:4324;;;;;;;;22888:4360;;;;22768:4486;;22707:4547;;:::o;27998:2943::-;-1:-1:-1;;;;;;;28134:41:1;;;28130:177;;28207:6;28195:9;:18;28191:86;;;28240:22;;;;;;;;;;;;;;28191:86;27998:2943;;;:::o;28130:177::-;28369:4;-1:-1:-1;;;;;28353:20:1;:12;:10;:12::i;:::-;-1:-1:-1;;;;;28353:20:1;;28349:54;;28382:21;;;;;;;;;;;;;;28349:54;28461:23;260:42:3;28461:51:1;;29622:4;29616:11;29663:6;29657:3;29651:4;29647:14;29640:30;29761:9;29755:3;29749:4;29745:14;29738:33;29912:4;29906;29902:15;29896:3;29890:4;29886:14;29879:39;30314:5;30308:4;30304:16;30298:3;30292:4;30288:14;30281:40;30453:34;30447:3;30441:4;30437:14;30430:58;30686:4;30680;30674;30668:3;30662:4;30658:14;30652:4;30635:15;30628:5;30623:68;30613:312;;30804:4;30798:11;30850:16;30844:4;30841:1;30826:41;30894:16;30891:1;30884:27;1309:272:6;-1:-1:-1;;;;;;;1400:29:6;;;1396:179;;1445:34;1461:9;1472:6;1445:15;:34::i;1396:179::-;1510:54;1539:5;1546:9;1557:6;1510:28;:54::i;20166:1707:0:-;20337:2;20331:4;20324:16;20394:6;20388:4;20381:20;20459:34;20453:4;20446:48;20653:4;20647;20641;20635;20632:1;20625:5;20618;20613:45;20705:7;20701:1;20694:4;20688:11;20685:18;20681:32;20671:1089;;20796:7;20777:16;20768:5;20756:18;20749:26;20746:48;20743:61;20733:1013;;20841:1;20835:4;20828:15;20906:34;20900:4;20893:48;21043:4;21031:10;21025:4;21019;21016:1;21009:5;21002;20997:51;20993:56;21106:6;21100:4;21093:20;21289:4;21283;21277;21271;21268:1;21261:5;21254;21249:45;21238:56;;21349:7;21345:1;21338:4;21332:11;21329:18;21325:32;21315:413;;21547:7;21528:16;21519:5;21507:18;21500:26;21497:48;21494:61;21484:222;;21600:10;21594:4;21587:24;21675:4;21669;21662:18;21484:222;20671:1089;21786:1;21780:4;21773:15;20166:1707;;;:::o;31810:846:1:-;31985:19;32020:12;32016:634;;;32136:14;32153:59;32175:20;;;;;;;;:::i;:::-;32197:14;32153:21;:59::i;:::-;32136:76;-1:-1:-1;32226:71:1;32244:15;;;;:8;:15;:::i;:::-;32261:8;:14;;;32277:12;;32291:5;32226:17;:71::i;:::-;-1:-1:-1;32387:6:1;32325:59;32347:20;;;;;;;;:::i;:::-;32369:14;32325:21;:59::i;:::-;:68;;;;:::i;:::-;32311:82;;32034:370;32016:634;;;32469:16;32488:70;32506:15;;;;:8;:15;:::i;:::-;32523:8;:14;;;32539:12;;32553:4;32488:17;:70::i;:::-;32469:89;;32586:53;32604:3;32609:8;:29;;;32586:17;:53::i;:::-;32572:67;;32410:240;32016:634;31810:846;;;;;;;:::o;18355:2055::-;18566:19;18649:62;18663:16;;;;;;;;:::i;:::-;18681:10;;;;:5;:10;:::i;:::-;18693:5;:17;;;18649:13;:62::i;:::-;18722:12;18814:10;;;;18848:14;;;;;:57;;-1:-1:-1;7335:4:1;18868:30;;18867:37;;18848:57;18838:67;-1:-1:-1;18939:17:1;;;;18975:14;;;;;:26;;;18994:7;18993:8;18975:26;18971:218;;;19021:63;19042:16;;;;;;;;:::i;:::-;19060:12;;;;:3;:12;:::i;:::-;19074:9;19021:20;:63::i;:::-;19134:22;;;18971:218;19337:1;19301:24;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19301:38:1;;;:94;;;;-1:-1:-1;682:42:6;19343:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19343:52:1;;;19301:94;:253;;;;-1:-1:-1;19486:16:1;;;;;;;;:::i;:::-;-1:-1:-1;;;;;19479:34:1;;19522:4;19529:24;;;;;;;;:::i;:::-;19479:75;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;19479:75:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;19479:75:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19467:9;:87;19301:253;19239:503;;;19628:99;19665:16;;;;;;;;:::i;:::-;19683:24;;;;;;;;:::i;19628:99::-;-1:-1:-1;;7514:4:1;19930:29;;19929:36;;19990:62;20000:8;20010:12;;19929:36;20046:4;19990:9;:62::i;:::-;19976:76;;20080:8;:18;;;20066:11;:32;20062:69;;;20107:24;;;;;;;;;;;;;;20062:69;20179:7;20175:229;;;20222:10;;;;20246:67;20267:20;;;;;;;;:::i;:::-;20289:12;;;;:3;:12;:::i;20246:67::-;20355:24;;;;20175:229;18587:1823;;18355:2055;;;;;;;;:::o;21007:1330::-;21202:28;21233:14;;21202:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21202:45:1;;-1:-1:-1;;;;7906:4:1;21320:44;;:49;21316:264;;8039:2;21404:37;;;8183:6;21404:67;21485:84;21518:15;21404:67;21561:6;21485:25;:84::i;:::-;21371:209;21316:264;21716:1;21678:26;;;;;;;;:::i;:::-;-1:-1:-1;;;;;21678:40:1;;;:85;;;;-1:-1:-1;;;;;;21722:41:1;;682:42:6;21722:41:1;;21678:85;:224;;;;-1:-1:-1;;;;;;21836:23:1;;;21868:4;21875:26;;;;;;;;:::i;:::-;21836:66;;;;;;;;;;-1:-1:-1;;;;;5862:55:7;;;21836:66:1;;;5844:74:7;5954:55;;5934:18;;;5927:83;5817:18;;21836:66:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21827:6;:75;21678:224;21624:441;;;21964:90;22001:5;22008:26;;;;;;;;:::i;21964:90::-;22118:19;7722:4;22142:5;:34;22181:1;22141:41;22140:90;;22214:10;:16;;;22140:90;;;22186:25;22195:16;;;;22186:6;:25;:::i;:::-;22118:112;-1:-1:-1;22272:58:1;22282:17;;;;:10;:17;:::i;:::-;22301:11;22314:15;22272:9;:58::i;:::-;21192:1145;;21007:1330;;;;;;:::o;34286:1320::-;34417:16;34449:12;34527:4;34521:11;34576;34563;34558:3;34545:43;34693:21;;;34727:4;34689:32;-1:-1:-1;;34685:48:1;34679:4;34672:62;34855:1;;34702:11;34697:3;34827:5;34819:6;34812:5;34807:50;34796:61;;;34882:7;34881:8;:23;;;;34893:11;34881:23;34877:723;;;35032:16;35078:4;35072:11;35065:18;;35112:14;35107:3;35100:27;35221:14;35218:1;35211:4;35206:3;35202:14;35187:49;35302:46;35306:35;;;35302:46;-1:-1:-1;;35298:62:1;35292:4;35285:76;35414:7;35409:181;;35517:3;35511:10;35504:4;35499:3;35495:14;35488:34;35409:181;34439:1167;34286:1320;;;;;;;:::o;984:445:2:-;1072:10;1096:35;;;1092:331;;-1:-1:-1;1372:25:2;1376:14;1372:25;1359:39;1353:4;1349:50;1092:331;984:445;:::o;1587:220:6:-;1666:12;1683:9;-1:-1:-1;;;;;1683:14:6;1705:6;1718;1683:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1665:64;;;1744:7;1739:62;;1774:16;;;;;;;;;;;;;;16340:887:0;16503:2;16497:4;16490:16;16560:6;16554:4;16547:20;16625:34;16619:4;16612:48;16821:4;16815;16809;16803;16800:1;16793:5;16786;16781:45;16873:7;16869:1;16862:4;16856:11;16853:18;16849:32;16839:275;;16964:7;16945:16;16936:5;16924:18;16917:26;16914:48;16911:61;16901:199;;17009:10;17003:4;16996:24;17077:4;17071;17064:18;732:265:6;803:15;-1:-1:-1;;;;;;;834:29:6;;;830:161;;-1:-1:-1;;;;;;889:12:6;;;830:161;;;942:38;968:5;975:4;942:25;:38::i;:::-;932:48;;830:161;732:265;;;;:::o;35913:382:1:-;36001:12;;36042:15;:10;36055:2;36042:15;:::i;:::-;36085:10;;36025:32;;-1:-1:-1;36071:11:1;36025:32;36080:2;36071:11;:::i;:::-;:24;36067:60;;;36104:23;;;;;;;;;;;;;;36067:60;36251:27;;;;36264:4;36251:27;36245:34;;35913:382;-1:-1:-1;;35913:382:1:o;561:423:5:-;732:11;;716:13;:8;727:2;716:13;:::i;:::-;:27;712:92;;;766:27;;;;;;;;;;;;;;712:92;931:30;;945:4;931:30;924:44;561:423::o;32881:885:1:-;32969:12;33101:1;33098;33091:4;33085:11;33078:4;33072;33068:15;33061:5;33053:6;33046:5;33041:62;33030:73;;33128:7;33123:637;;33339:4;33333:11;33293:16;33361:27;;;33293:16;33479:1;33472:4;33463:14;;33448:49;33563:46;33567:35;;;33563:46;-1:-1:-1;;33559:62:1;33553:4;33546:76;33683:10;;33580:4;33571:14;;33660:34;33123:637;32959:807;32881:885;;;:::o;22000:739:0:-;22074:14;22179:7;22173:4;22166:21;22246:34;22240:4;22233:48;22678:4;22672;22666;22660;22653:5;22646;22635:48;22573:4;22555:16;22552:26;22463:242;22436:4;22430:11;22345:378;22319:404;;22000:739;;;;:::o;14:749:7:-;134:6;142;150;203:2;191:9;182:7;178:23;174:32;171:52;;;219:1;216;209:12;171:52;264:23;;;-1:-1:-1;362:2:7;347:18;;334:32;389:18;378:30;;375:50;;;421:1;418;411:12;375:50;444:22;;497:4;489:13;;485:27;-1:-1:-1;475:55:7;;526:1;523;516:12;475:55;566:2;553:16;592:18;584:6;581:30;578:50;;;624:1;621;614:12;578:50;677:7;672:2;662:6;659:1;655:14;651:2;647:23;643:32;640:45;637:65;;;698:1;695;688:12;637:65;14:749;;729:2;721:11;;;;;-1:-1:-1;751:6:7;;-1:-1:-1;;;14:749:7:o;768:157::-;830:5;875:2;866:6;861:3;857:16;853:25;850:45;;;891:1;888;881:12;850:45;-1:-1:-1;913:6:7;768:157;-1:-1:-1;768:157:7:o;930:155::-;990:5;1035:2;1026:6;1021:3;1017:16;1013:25;1010:45;;;1051:1;1048;1041:12;1090:157;1151:5;1196:3;1187:6;1182:3;1178:16;1174:26;1171:46;;;1213:1;1210;1203:12;1252:347;1303:8;1313:6;1367:3;1360:4;1352:6;1348:17;1344:27;1334:55;;1385:1;1382;1375:12;1334:55;-1:-1:-1;1408:20:7;;1451:18;1440:30;;1437:50;;;1483:1;1480;1473:12;1437:50;1520:4;1512:6;1508:17;1496:29;;1572:3;1565:4;1556:6;1548;1544:19;1540:30;1537:39;1534:59;;;1589:1;1586;1579:12;1534:59;1252:347;;;;;:::o;1604:196::-;1672:20;;-1:-1:-1;;;;;1721:54:7;;1711:65;;1701:93;;1790:1;1787;1780:12;1701:93;1604:196;;;:::o;1805:1103::-;2010:6;2018;2026;2034;2042;2050;2058;2066;2119:3;2107:9;2098:7;2094:23;2090:33;2087:53;;;2136:1;2133;2126:12;2087:53;2181:23;;;-1:-1:-1;2301:2:7;2286:18;;2273:32;;-1:-1:-1;2350:65:7;2407:7;2402:2;2387:18;;2350:65;:::i;:::-;2340:75;;2434:64;2490:7;2484:3;2473:9;2469:19;2434:64;:::i;:::-;2424:74;;2517:65;2574:7;2568:3;2557:9;2553:19;2517:65;:::i;:::-;2507:75;;2633:3;2622:9;2618:19;2605:33;2661:18;2653:6;2650:30;2647:50;;;2693:1;2690;2683:12;2647:50;2732:58;2782:7;2773:6;2762:9;2758:22;2732:58;:::i;:::-;2809:8;;-1:-1:-1;2706:84:7;-1:-1:-1;2863:39:7;;-1:-1:-1;2897:3:7;2882:19;;2863:39;:::i;:::-;2853:49;;1805:1103;;;;;;;;;;;:::o;3095:1463::-;3349:6;3357;3365;3373;3381;3389;3397;3405;3413;3421;3474:3;3462:9;3453:7;3449:23;3445:33;3442:53;;;3491:1;3488;3481:12;3442:53;3536:23;;;-1:-1:-1;3656:2:7;3641:18;;3628:32;;-1:-1:-1;3705:65:7;3762:7;3757:2;3742:18;;3705:65;:::i;:::-;3695:75;;3789:64;3845:7;3839:3;3828:9;3824:19;3789:64;:::i;:::-;3779:74;;3872:65;3929:7;3923:3;3912:9;3908:19;3872:65;:::i;:::-;3862:75;;3988:3;3977:9;3973:19;3960:33;4016:18;4008:6;4005:30;4002:50;;;4048:1;4045;4038:12;4002:50;4087:58;4137:7;4128:6;4117:9;4113:22;4087:58;:::i;:::-;4164:8;;-1:-1:-1;4061:84:7;-1:-1:-1;4218:66:7;;-1:-1:-1;4276:7:7;4270:3;4255:19;;4218:66;:::i;:::-;4208:76;;4337:3;4326:9;4322:19;4309:33;4367:18;4357:8;4354:32;4351:52;;;4399:1;4396;4389:12;4351:52;4438:60;4490:7;4479:8;4468:9;4464:24;4438:60;:::i;:::-;4412:86;;4517:8;4507:18;;;4544:8;4534:18;;;3095:1463;;;;;;;;;;;;;:::o;4563:186::-;4622:6;4675:2;4663:9;4654:7;4650:23;4646:32;4643:52;;;4691:1;4688;4681:12;4643:52;4714:29;4733:9;4714:29;:::i;4754:911::-;4943:6;4951;4959;4967;4975;4983;5036:3;5024:9;5015:7;5011:23;5007:33;5004:53;;;5053:1;5050;5043:12;5004:53;5098:23;;;-1:-1:-1;5164:65:7;5221:7;5216:2;5201:18;;5164:65;:::i;:::-;5154:75;;5248:64;5304:7;5298:3;5287:9;5283:19;5248:64;:::i;:::-;5238:74;;5331:66;5389:7;5383:3;5372:9;5368:19;5331:66;:::i;:::-;5321:76;;5448:3;5437:9;5433:19;5420:33;5476:18;5468:6;5465:30;5462:50;;;5508:1;5505;5498:12;5462:50;5547:58;5597:7;5588:6;5577:9;5573:22;5547:58;:::i;:::-;4754:911;;;;-1:-1:-1;4754:911:7;;-1:-1:-1;4754:911:7;;5624:8;;4754:911;-1:-1:-1;;;4754:911:7:o;6021:184::-;6091:6;6144:2;6132:9;6123:7;6119:23;6115:32;6112:52;;;6160:1;6157;6150:12;6112:52;-1:-1:-1;6183:16:7;;6021:184;-1:-1:-1;6021:184:7:o;6210:::-;-1:-1:-1;;;6259:1:7;6252:88;6359:4;6356:1;6349:15;6383:4;6380:1;6373:15;6399:184;-1:-1:-1;;;6448:1:7;6441:88;6548:4;6545:1;6538:15;6572:4;6569:1;6562:15;6588:381;6679:4;6737:11;6724:25;6827:66;6816:8;6800:14;6796:29;6792:102;6772:18;6768:127;6758:155;;6909:1;6906;6899:12;6758:155;6930:33;;;;;6588:381;-1:-1:-1;;6588:381:7:o;6974:580::-;7051:4;7057:6;7117:11;7104:25;-1:-1:-1;;7196:8:7;7180:14;7176:29;7172:102;7152:18;7148:127;7138:155;;7289:1;7286;7279:12;7138:155;7316:33;;7368:20;;;-1:-1:-1;7411:18:7;7400:30;;7397:50;;;7443:1;7440;7433:12;7397:50;7476:4;7464:17;;-1:-1:-1;7507:14:7;7503:27;;;7493:38;;7490:58;;;7544:1;7541;7534:12;7559:604;7652:4;7658:6;7718:11;7705:25;-1:-1:-1;;7797:8:7;7781:14;7777:29;7773:102;7753:18;7749:127;7739:155;;7890:1;7887;7880:12;7739:155;7917:33;;7969:20;;;-1:-1:-1;8012:18:7;8001:30;;7998:50;;;8044:1;8041;8034:12;7998:50;8077:4;8065:17;;-1:-1:-1;8128:1:7;8124:14;;;8108;8104:35;8094:46;;8091:66;;;8153:1;8150;8143:12;8421:184;-1:-1:-1;;;8470:1:7;8463:88;8570:4;8567:1;8560:15;8594:4;8591:1;8584:15;8610:125;8675:9;;;8696:10;;;8693:36;;;8709:18;;:::i;8929:128::-;8996:9;;;9017:11;;;9014:37;;;9031:18;;:::i;9062:546::-;9237:6;9226:9;9219:25;9280:2;9275;9264:9;9260:18;9253:30;9200:4;9312:6;9306:13;9355:6;9350:2;9339:9;9335:18;9328:34;9414:6;9409:2;9401:6;9397:15;9392:2;9381:9;9377:18;9371:50;9470:1;9465:2;9456:6;9445:9;9441:22;9437:31;9430:42;9599:2;-1:-1:-1;;9524:2:7;9516:6;9512:15;9508:88;9497:9;9493:104;9489:113;9481:121;;;9062:546;;;;;:::o;9823:168::-;9896:9;;;9927;;9944:15;;;9938:22;;9924:37;9914:71;;9965:18;;:::i","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"bridge(bytes32,(address,address,uint256),(address,uint256),(address,address,uint256),bytes)","signatureHash4":"0xb18248d5","signatureHash32":"0xb18248d58fa1f8b69e66b9874f8218e3277241cacc27efc9cd86d664eab52186"},{"signature":"performActions(bytes32,(uint256,bytes,uint256[])[])","signatureHash4":"0x197aa51e","signatureHash32":"0x197aa51e898ab8fbc169b1c2a5b9e333a890f8d50a96924e5485c6281003c564"},{"signature":"swapAndBridge(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,(address,address,uint256),bytes)","signatureHash4":"0x324012e2","signatureHash32":"0x324012e29c3b65f46d21f8b489498f509f79ec085b08b1bcdc8b81aeed033d0d"},{"signature":"swap(bytes32,uint256,(address,address,uint256),(address,uint256),(address,address,address,uint256,uint256,uint256),bytes,address)","signatureHash4":"0x1bb1a530","signatureHash32":"0x1bb1a530db428e5881e597241ea4a27d82bcff8bc7c0c7e86b703e0a35a4eca1"}],"event":[{"signature":"RequestExecuted(bytes32)","signatureHash4":"0xe2a75259","signatureHash32":"0xe2a752598b97815acff854b1d0b6d5c7f33b848bcbb541df9b76038287282467"}],"error":[{"signature":"CallerNotSignedUser()","signatureHash4":"0x85132e0f","signatureHash32":"0x85132e0f034419bc48eb983af91ecac748c3312286a287c4c372e3bf1ea8ed14"},{"signature":"CallFailed(uint256,bytes)","signatureHash4":"0x5c0dee5d","signatureHash32":"0x5c0dee5d32a1e145396705da49c1e64a2b1d63387f78c2697100f655567f5de9"},{"signature":"FutureSplice(uint256,uint256)","signatureHash4":"0x8ac3a5c3","signatureHash32":"0x8ac3a5c35270a0ee66428530cd74c4fad877487661ab37f41bf9843db0e65d4d"},{"signature":"InsufficientMsgValue()","signatureHash4":"0x78f38f76","signatureHash32":"0x78f38f76a91d822d65fa495aa19682312300fa9b086584d78e163eda89de96d8"},{"signature":"MissingNativeValue(uint256)","signatureHash4":"0x4208b27c","signatureHash32":"0x4208b27c9b90fda1119ab23fc3468d691a814850c0162c432f4258bbe6c36d07"},{"signature":"ReturnDataOutOfBounds()","signatureHash4":"0x6ef2ffe2","signatureHash32":"0x6ef2ffe2356548d37e77ce598662eaf6ee6168ffa7bf1923bf23bdea7d661216"},{"signature":"SpliceOutOfBounds(uint256,uint256)","signatureHash4":"0xba5d879f","signatureHash32":"0xba5d879f1fc0ca7e02d2179b89496ecedcb3efbb219279674e0b6980638862fb"},{"signature":"SplicePositionOutOfBounds()","signatureHash4":"0x7a353f8a","signatureHash32":"0x7a353f8ab537c5839c3120b36bd9963dc6eb59e18cbbb1637bdacc9dcc74dad4"},{"signature":"SwapOutputInsufficient()","signatureHash4":"0x3453a1e7","signatureHash32":"0x3453a1e7efb47fe78b2fcb4439d749650a6330fd3e468f4a1aa3a8356ae1a4d6"},{"signature":"TransferFailed()","signatureHash4":"0x90b8ec18","signatureHash32":"0x90b8ec1877afffd816d05d9b13947f3ff18ec5851c38bad15ec2b710f92391b1"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x50cFe7c1938dB66A1a6D2e86D36F39FBef3d5c4a"}