{"matchId":"14055793","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-01-17T16:10:48Z","creationBytecode":{"onchainBytecode":"0x6080806040523461014557604051601f611cb138819003918201601f19168301916001600160401b03831184841017610131578084926020946040528339810103126100e157516001600160a01b0381168082036100dd576100d85750335b6001600160a01b031680156100c5575f80546001600160a01b031981168317825560405192916001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a36001600255611b1e90816101938239f35b631e4fbdf760e01b5f525f60045260245ffd5b61005e565b5f80fd5b60405162461bcd60e51b815260206004820152602260248201527f414249206465636f64696e673a207475706c65206461746120746f6f2073686f6044820152611c9d60f21b6064820152608490fd5b634e487b7160e01b5f52604160045260245ffd5b62461bcd60e51b815260206004820152602260248201527f45746865722073656e7420746f206e6f6e2d70617961626c652066756e63746960448201526137b760f11b6064820152608490fdfe60806040526004361015610015575b36610f5c57005b5f3560e01c8063105a88e31461015057806326604a431461014b5780632f9182cc1461014657806331f7d964146101415780633d18b2af1461013c57806342a6f7a514610137578063476b6acf146101325780634bfc50141461012d5780634cd10b8e14610128578063715018a6146101235780637f4c4847146100f65780638da5cb5b1461011e578063b139012d14610119578063cd86798514610114578063ceb68c231461010f578063d28c38041461010a578063de1eb9a314610105578063eb667c6c14610100578063f2fde38b146100fb5763fd7070460361000e575b610902565b610ed7565b610eaa565b610dbc565b610d86565b610d07565b61099b565b610948565b610921565b6108ab565b6107fd565b6106cf565b610692565b610560565b610521565b6104f3565b61046d565b6102d2565b61028b565b60405162461bcd60e51b815260206004820152602260248201527f45746865722073656e7420746f206e6f6e2d70617961626c652066756e63746960448201526137b760f11b6064820152608490fd5b60405162461bcd60e51b815260206004820152602260248201527f414249206465636f64696e673a207475706c65206461746120746f6f2073686f6044820152611c9d60f21b6064820152608490fd5b60405162461bcd60e51b815260206004820152602260248201527f414249206465636f64696e673a20696e76616c6964207475706c65206f666673604482015261195d60f21b6064820152608490fd5b600435906001600160a01b038216820361025b57565b5f80fd5b602435906001600160a01b038216820361025b57565b60a435906001600160a01b038216820361025b57565b346102cd5760203660031901126102c8576001600160a01b036102ac610245565b165f5260016020526020600160405f2054161515604051908152f35b6101a5565b610155565b346102cd5760203660031901126102c857600435806102f95750602060015b604051908152f35b6020906102f1565b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a1c9c985e481bd9999cd95d60aa1b6064820152608490fd5b634e487b7160e01b5f52604160045260245ffd5b90601f801991011681019081106001600160401b0382111761037c57604052565b610347565b6040519061039060808361035b565b565b6001600160401b03811161037c57601f01601f191660200190565b9291926103b982610392565b916103c7604051938461035b565b8294818452818301116103e3578281602093845f960137010152565b60405162461bcd60e51b815260206004820152602760248201527f414249206465636f64696e673a20696e76616c69642062797465206172726179604482015266040d8cadccee8d60cb1b6064820152608490fd5b602435906001600160e01b03198216820361025b57565b60643590811515820361025b57565b60843590811515820361025b57565b346102cd5760a03660031901126102c857610486610245565b6024356001600160401b0381116104ee57366023820112156104e9576104b69036906024816004013591016103ad565b60443591906001600160e01b03198316830361025b576104e7926104d861044f565b916104e161045e565b93610fb3565b005b610301565b6101f5565b346102cd575f3660031901126102c857602060405173eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee8152f35b346102cd5760203660031901126102c8576001600160a01b03610542610245565b165f526001602052602064ffffffffff60405f205416604051908152f35b346102cd5760403660031901126102c857610579610245565b610581610438565b6105896111bc565b6001600160a01b0382165f818152600160205260409020549091906105c0906105bc9064ffffffffff165b600116151590565b1590565b610683576001600160e01b031981169283156106745761063761061c61064e936106086105fd8560018060a01b03165f52600160205260405f2090565b5464ffffffffff1690565b60ff1660d89190911c64ffffffff00161790565b6001600160a01b039092165f90815260016020526040902090565b9064ffffffffff1664ffffffffff19825416179055565b7fd2f6827debfb2832d419a5f1fcc2bf414c1e1df8fdd7a232336079a86d3da1815f80a3005b6342868c9b60e01b5f5260045ffd5b63775a7b0960e11b5f5260045ffd5b346102cd5760203660031901126102c8576001600160a01b036106b3610245565b165f5260016020526020600260405f2054161515604051908152f35b346102cd5760203660031901126102c8576001600160a01b036106f0610245565b165f5260016020526020600460405f2054161515604051908152f35b9181601f840112156104e9578235916001600160401b03831161077f576020838186019501011161073957565b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a727261792073747269646560a81b6064820152608490fd5b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a0e4e4c2f240d8cadccee8d60ab1b6064820152608490fd5b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b9060206107fa9281815201906107c5565b90565b346102cd5760c03660031901126102c857610816610245565b61081e61025f565b906044356001600160401b0381116104ee5761083e90369060040161070c565b6064356084359161084d610275565b9361085661122f565b831561089c576001600160a01b0385161561088d576108899661087896611327565b6001600255604051918291826107e9565b0390f35b63a355f88960e01b5f5260045ffd5b63747a60fb60e01b5f5260045ffd5b346102cd575f3660031901126102c8576108c36111bc565b5f80546001600160a01b0319811682556001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a3005b346102cd575f3660031901126102c85760206040516321524110198152f35b346102cd575f3660031901126102c8575f546040516001600160a01b039091168152602090f35b346102cd5760203660031901126102c8576001600160a01b03610969610245565b165f9081526001602090815260409091205460d81b6001600160e01b0319166040516001600160e01b03199091168152f35b346102cd5760803660031901126102c8576109b4610245565b6109bc61025f565b906044356001600160401b0381116104ee576109dc90369060040161070c565b9190606435926109ea61122f565b6001600160a01b0385165f908152600160205260409020610a0a906105fd565b6001811615610cf8576001600160a01b0384169473eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee8614938415610c4f576004831615610c405747928315610c3157610a575f856115c5565b959095938610610c22575b859187159081610c15575b50610b6b575b5f9291610a96918493610a918d610a8b3685856103ad565b906116e9565b6117d0565b868214610b5257602081519101868b5af195610ab06112e1565b965b15610b3357604051610889986001600160a01b0316907f76511bb8950b82fe2ee5f747e5a7929769055ce5ade161da73b869147b1f5e3f9080610af68b8983611310565b0390a380151580610b2c575b610b18575b6001600255604051808888826107e9565b5f610b22956118a6565b5f80808080610b07565b505f610b02565b60405163f8e68f2360e01b815280610b4e89600483016107e9565b0390fd5b602081519101828b5af195610b656112e1565b96610ab2565b883b15610c105760405163313ce56760e01b8152916020836004818d5afa918215610c0b575f9460ff610a969487968791610bdc575b501660128110610bb8575b50945091509150610a73565b610bd5919350610bca610bcf9161110e565b6112d3565b896110f6565b915f610bac565b610bfe915060203d602011610c04575b610bf6818361035b565b8101906112ba565b5f610ba1565b503d610bec565b6112af565b61124d565b600216151590505f610a6d565b633b38932f60e11b5f5260045ffd5b63565dfaef60e11b5f5260045ffd5b637ca2885760e01b5f5260045ffd5b86939291933b15610c10576040516370a0823160e01b8152336004820152916020836024818b5afa928315610c0b575f93610cc7575b508293610c925f856115c5565b949080978110610cb857610cac610cb392308d339061160d565b8b8b611664565b610a62565b631762402160e11b5f5260045ffd5b610cea91935060203d602011610cf1575b610ce2818361035b565b8101906112a0565b915f610c85565b503d610cd8565b63077b4faf60e01b5f5260045ffd5b346102cd5760203660031901126102c857610d20610245565b610d286111bc565b6001600160a01b03165f81815260016020819052604090912054161561068357805f52600160205260405f2064ffffffffff1981541690557fe71f3a50e5ad81964f352c411f1d45e35438ecd1acecef59ac81d9fbbf6cbc0a5f80a2005b346102cd5760403660031901126102c8576060610da760243560043561112b565b90604051921515835260208301526040820152f35b346102cd5760203660031901126102c857610dd5610245565b610ddd61115f565b506001600160a01b03165f9081526001602052604090205461088990610e69610e58610e48610e3f64ffffffff00610e1361115f565b600187161515815260028716151560208201526004871615156040820152951660081c63ffffffff1690565b63ffffffff1690565b60e01b6001600160e01b03191690565b6001600160e01b0319166060830152565b60405191829182919091606060808201938051151583526020810151151560208401526040810151151560408401528163ffffffff60e01b91015116910152565b346102cd5760403660031901126102c8576040610ecb602435600435611193565b82519182526020820152f35b346102cd5760203660031901126102c857610ef0610245565b610ef86111bc565b6001600160a01b03168015610f49575f80546001600160a01b03198116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a3005b631e4fbdf760e01b5f525f60045260245ffd5b60405162461bcd60e51b815260206004820152602960248201527f556e6b6e6f776e207369676e617475726520616e64206e6f2066616c6c6261636044820152681ac81919599a5b995960ba1b6064820152608490fd5b939291610fbe6111bc565b6001600160a01b03851694851561109557825115611086576001600160e01b0319821615610674576001600160a01b0381165f90815260016020526040902061100a906105b4906105fd565b6110775761063761061c7f55e854e53b29a09bfbe28c9e867d99a35dbcc693f17da80c10b4e4607d747a3a9661105e61106395610e58611048610381565b60018152938a1515602086015215156040850152565b6111e2565b611072604051928392836110a4565b0390a2565b6324ec133760e11b5f5260045ffd5b630364bbe960e61b5f5260045ffd5b630681d31960e51b5f5260045ffd5b906110bc6020919493946040845260408401906107c5565b931515910152565b634e487b7160e01b5f52601160045260245ffd5b81156110e2570490565b634e487b7160e01b5f52601260045260245ffd5b8181029291811591840414171561110957565b6110c4565b601203906012821161110957565b601f1981019190821161110957565b908015611156578061114061114592846110d8565b6110f6565b908181039081116111095781151592565b50801515915f90565b60405190608082018281106001600160401b0382111761037c576040525f6060838281528260208201528260408201520152565b919080156111b757806111406111a992856110d8565b918281039081116111095790565b505f90565b5f546001600160a01b031633036111cf57565b63118cdaa760e01b5f523360045260245ffd5b5f908051611226575b602081015161121c575b6040810151611211575b6060015160d81c64ffffffff00161790565b6004909117906111ff565b90600217906111f5565b600191506111eb565b600280541461123e5760028055565b633ee5aeb560e01b5f5260045ffd5b60405162461bcd60e51b815260206004820152602560248201527f54617267657420636f6e747261637420646f6573206e6f7420636f6e7461696e60448201526420636f646560d81b6064820152608490fd5b908160209103126102c8575190565b6040513d5f823e3d90fd5b908160209103126102c8575160ff8116810361025b5790565b604d811161110957600a0a90565b3d1561130b573d906112f282610392565b91611300604051938461035b565b82523d5f602084013e565b606090565b6040906107fa9392815281602082015201906107c5565b94919390956113496105fd8860018060a01b03165f52600160205260405f2090565b946001861615610cf8576001600160a01b03871673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee811496909190871561153e576004811615610c405747958615610c315761139990876115c5565b979097958810610c22575b8a88928a159081611531575b5061149f575b916113cd915f94610a918695610a8b3685856103ad565b88821461148657602081519101888c5af1976113e76112e1565b985b1561146b576040516001600160a01b03909116907f76511bb8950b82fe2ee5f747e5a7929769055ce5ade161da73b869147b1f5e3f908061142b8c8a83611310565b0390a381151580611459575b611445575b50505050505090565b61144e956118a6565b5f808080808061143c565b506001600160a01b0381161515611437565b60405163f8e68f2360e01b815280610b4e8b600483016107e9565b602081519101828c5af1976114996112e1565b986113e9565b5090833b15610c105760405163313ce56760e01b815290602082600481885afa928315610c0b575f948d60ff87966113cd968891611512575b5016601281106114f0575b50929450945091506113b6565b610a91919450611505610bca61150b9261110e565b8d6110f6565b93906114e3565b61152b915060203d602011610c0457610bf6818361035b565b5f6114d8565b600216151590505f6113b0565b829694963b15610c10576040516370a0823160e01b815233600482015294602086602481875afa958615610c0b575f966115a4575b5061157f8697876115c5565b969080998110610cb85761159861159f9230338961160d565b8c86611664565b6113a4565b6115be91965060203d602011610cf157610ce2818361035b565b945f611573565b90918215611606576115db8361114081856110d8565b92838303838111611109579284156115f1575050565b63d9e3812360e01b5f5260045260245260445ffd5b9150905f90565b6040516323b872dd60e01b60208201526001600160a01b0392831660248201529290911660448301526064808301939093529181526103909161165160848361035b565b6119a5565b906020820180921161110957565b916001600160a01b0383169190823b15610c1057604051636eb1769f60e11b81523060048201526001600160a01b038316602482015292602090849060449082905afa928315610c0b575f936116c8575b50820180921161110957610390926119fd565b6116e291935060203d602011610cf157610ce2818361035b565b915f6116b5565b90600481511061177957602001519061173d61173064ffffffffff61171e8460018060a01b03165f52600160205260405f2090565b541660d81b6001600160e01b03191690565b6001600160e01b03191690565b6001600160e01b0319831603611751575050565b6375e81e2960e11b5f526001600160a01b03166004526001600160e01b03191660245260445ffd5b6040516316a434ff60e21b815260206004820152602860248201527f43616c6c6461746120746f6f2073686f727420666f722066756e6374696f6e2060448201526739b2b632b1ba37b960c11b6064820152608490fd5b6117db9136916103ad565b602481511061182c57906004915b6117f3815161111c565b831161182657602083820101926321524110198451146118205761181991929350611656565b91906117e9565b50915290565b91505090565b6040516316a434ff60e21b815260206004820152604560248201527f43616c6c206461746120697320746f6f2073686f727420746f20696e636c756460448201527f652073656c6563746f7220616e64206174206c65617374206f6e65207061726160648201526436b2ba32b960d91b608482015260a490fd5b9290949391935f1461192d575f808080876001600160a01b038a165af16118cb6112e1565b501561191e577feb89cc1a0c6b99cb87f8608d2089862fc42b7f8cb003e2401ea646032177b28c925b604080519586526020860192909252908401919091526001600160a01b03908116931691606090a3565b63132fd5e360e11b5f5260045ffd5b60405163a9059cbb60e01b60208201526001600160a01b0386166024820152604481018590527feb89cc1a0c6b99cb87f8608d2089862fc42b7f8cb003e2401ea646032177b28c93906119a09061199181606481015b03601f19810183528261035b565b6001600160a01b0383166119a5565b6118f4565b905f602091828151910182855af1156112af575f513d6119f457506001600160a01b0381163b155b6119d45750565b635274afe760e01b5f9081526001600160a01b0391909116600452602490fd5b600114156119cd565b60405163095ea7b360e01b60208083019182526001600160a01b0385166024840152604480840196909652948252929390925f90611a3c60648661035b565b84519082855af15f51903d81611a9c575b501590505b611a5b57505050565b60405163095ea7b360e01b60208201526001600160a01b0390931660248401525f60448401526103909261165190611a968160648101611983565b826119a5565b15159050611abc5750611a526001600160a01b0382163b15155b5f611a4d565b6001611a529114611ab656fe414249206465636f64696e673a20696e76616c69642063616c6c646174612061a264697066735822122076617063a96bad71bfcd134d654760133c1ba640afac43490299d5245590b95e64736f6c634300081b00330000000000000000000000007779ffb11d50fceae8e533b611b5cb5a1c1db3d4","recompiledBytecode":"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","sourceMap":"1304:12178:15:-:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;1850:10:12;;1821:54;-1:-1:-1;;;;;1304:12178:15;1273:26:0;;1269:95;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;3052:40:0;;-1:-1:-1;3052:40:0;1857:1:8;2061:21;1857:1;1304:12178:15;;;;;;;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;1304:12178:15;;-1:-1:-1;1322:31:0;1821:54:12;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122076617063a96bad71bfcd134d654760133c1ba640afac43490299d5245590b95e64736f6c634300081b0033","offset":7292}},"transformations":[{"type":"insert","offset":7345,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000007779ffb11d50fceae8e533b611b5cb5a1c1db3d4"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1304:12178:15:-:0;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;5927:12:12;1304:12178:15;;;5927:12:12;1304:12178:15;-1:-1:-1;1304:12178:15;;3770:27:11;3769:34;;1304:12178:15;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;5252:13;;;:28;1304:12178;5268:1;5252:28;1304:12178;;;;;;5252:28;1304:12178;5252:28;;;1304:12178;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;;;;;1304:12178:15;;;;;;-1:-1:-1;;1304:12178:15;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;:::o;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;3416:962:12;1304:12178:15;;;:::i;:::-;;;;:::i;:::-;3416:962:12;;:::i;:::-;1304:12178:15;;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;2003:42;1304:12178;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;1531:46:12;1304:12178:15;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;5339:35:12;;5340:34;;1304:12178:15;;5340:19:12;453:6:11;3770:27;3769:34;;3686:124;;5340:34:12;5339:35;;1304:12178:15;5339:35:12;5335:68;;-1:-1:-1;;;;;;1304:12178:15;;;5417:24:12;;5413:62;;5486:19;5508:47;5486:69;5508:19;;;;1304:12178:15;;;;;;;;5340:12:12;1304:12178:15;;;;;;;5508:19:12;1304:12178:15;;;;;5508:19:12;787:12:11;4846:19;1304:12178:15;;;;;;;4953:22:11;;4674:308;5508:47:12;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;5486:19:12;1304:12178:15;;;;;;;;;;;;5486:69:12;5571:35;-1:-1:-1;5571:35:12;;1304:12178:15;5413:62:12;5450:25;;;-1:-1:-1;5450:25:12;1304:12178:15;-1:-1:-1;5450:25:12;5335:68;5383:20;;;-1:-1:-1;5383:20:12;1304:12178:15;-1:-1:-1;5383:20:12;1304:12178:15;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;6283:12:12;1304:12178:15;;;526:6:11;1304:12178:15;-1:-1:-1;1304:12178:15;;4090:36:11;4089:43;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;6637:12:12;1304:12178:15;;;590:6:11;1304:12178:15;-1:-1:-1;1304:12178:15;;4384:27:11;4383:34;;1304:12178:15;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;-1:-1:-1;;1304:12178:15;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;2466:103:8;;;:::i;:::-;7914:13:15;;7910:43;;-1:-1:-1;;;;;1304:12178:15;;7967:27;7963:62;;1304:12178;8043:71;;;;:::i;:::-;1857:1:8;3068:21;1899:1;1304:12178:15;;;;;;;:::i;:::-;;;;7963:62;8003:22;;;-1:-1:-1;8003:22:15;1304:12178;-1:-1:-1;8003:22:15;7910:43;7936:17;;;-1:-1:-1;7936:17:15;1304:12178;-1:-1:-1;7936:17:15;1304:12178;;;;;;-1:-1:-1;;1304:12178:15;;;;1500:62:0;;:::i;:::-;1304:12178:15;;;-1:-1:-1;;;;;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;3052:40:0;1304:12178:15;;3052:40:0;1304:12178:15;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;1724:66;;1304:12178;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;;;6969:12:12;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;;1304:12178:15;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;2466:103:8;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;8979:19;;;1304:12178;8979:19;453:6:11;3770:27;;3769:34;9008:71:15;;-1:-1:-1;;;;;1304:12178:15;;;2003:42;9106:21;;;9216:1262;;;;590:6:11;4384:27;;4383:34;9291:68:15;;9449:21;9488:12;;;9484:42;;9613:37;-1:-1:-1;9613:37:15;;:::i;:::-;9589:61;;;;;9729:28;9725:64;;9216:1262;10537:41;10592:9;;;:46;;;;9216:1262;10588:252;;;9216:1262;-1:-1:-1;1304:12178:15;;11092:63;1304:12178;;;10935:34;1304:12178;1506:2;1304:12178;1506:2;;;:::i;:::-;10935:34;;:::i;:::-;11092:63;:::i;:::-;11279:94;;;;;11290:52;;;;;;;;;;;;:::i;:::-;11279:94;;11387:8;11383:40;;1304:12178;;;;-1:-1:-1;;;;;1304:12178:15;;11521:53;;1304:12178;11521:53;;;1304:12178;11521:53;:::i;:::-;;;;11632:8;;;:39;;;11279:94;11628:143;;11279:94;1857:1:8;3068:21;1899:1;1304:12178:15;;;11781:11;;1304:12178;;:::i;11628:143::-;-1:-1:-1;11751:8:15;;;:::i;:::-;11628:143;;;;;;;11632:39;;-1:-1:-1;11632:39:15;;11383:40;1304:12178;;-1:-1:-1;;;11404:19:15;;1304:12178;11404:19;1304:12178;;11404:19;;;:::i;:::-;;;;11279:94;11345:28;;;;;;;;;;;;:::i;:::-;11279:94;;;10588:252;10671:24;;;;;1304:12178;;-1:-1:-1;;;10671:24:15;;1304:12178;10671:24;1304:12178;;;10671:24;;;;;;;;-1:-1:-1;10671:24:15;590:6:11;11092:63:15;10671:24;;;;;;;10588:252;590:6:11;;1506:2:15;10713:19;;10709:121;;10588:252;;;;;;;;;;10709:121;10772:43;10795:19;;;;10788:27;10795:19;;:::i;:::-;10788:27;:::i;:::-;10772:43;;:::i;:::-;10709:121;;;;10671:24;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;:::i;10592:46::-;526:6:11;4090:36;4089:43;;;-1:-1:-1;10592:46:15;;;9725:64;9766:23;;;-1:-1:-1;9766:23:15;1304:12178;-1:-1:-1;9766:23:15;9484:42;9509:17;;;-1:-1:-1;9509:17:15;1304:12178;-1:-1:-1;9509:17:15;9291:68;9332:27;;;-1:-1:-1;9332:27:15;1304:12178;-1:-1:-1;9332:27:15;9216:1262;9885:35;;;;;;;;;1304:12178;;-1:-1:-1;;;9885:35:15;;9909:10;1304:12178;9885:35;;1304:12178;;9885:35;1304:12178;;;9885:35;;;;;;;;-1:-1:-1;9885:35:15;;;9216:1262;9875:45;;10007:37;;-1:-1:-1;10007:37:15;;:::i;:::-;9983:61;;;10123:28;;;10119:66;;10314:7;10453:13;10307:4;;9909:10;;10314:7;;:::i;:::-;10453:13;;;:::i;:::-;9216:1262;;10119:66;10160:25;;;-1:-1:-1;10160:25:15;1304:12178;-1:-1:-1;10160:25:15;9885:35;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;9008:71;9049:30;;;-1:-1:-1;9049:30:15;1304:12178;-1:-1:-1;9049:30:15;1304:12178;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;3770:27:11;3769:34;4795:68:12;;1304:12178:15;-1:-1:-1;1304:12178:15;4800:12:12;1304:12178:15;;;-1:-1:-1;1304:12178:15;;;;;;;;4916:19:12;-1:-1:-1;4916:19:12;;1304:12178:15;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;;;;;;;;2763:70:11;2788:45;2795:37;2802:29;702:12;1304:12178:15;;:::i;:::-;7306:12:12;2572:27:11;;2571:34;;1304:12178:15;;526:6:11;2645:36;;2644:43;;1304:12178:15;2615:26:11;;1304:12178:15;;2720:27:11;;2719:34;;1304:12178:15;2697:19:11;;1304:12178:15;2572:27:11;2803:22;590:6;1304:12178:15;;;;702:12:11;2802:29;590:6;;;;2795:37;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;702:12:11;2788:45;-1:-1:-1;;;;;;1304:12178:15;2763:22:11;;;1304:12178:15;;2763:70:11;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;2627:22:0;;2623:91;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;;;;;-1:-1:-1;;;;;1304:12178:15;;3052:40:0;;-1:-1:-1;3052:40:0;1304:12178:15;2623:91:0;2672:31;;;-1:-1:-1;2672:31:0;-1:-1:-1;1304:12178:15;;;-1:-1:-1;2672:31:0;1304:12178:15;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;1500:62:0;;;;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;;3654:19:12;;3650:46;;1304:12178:15;;3710:27:12;3706:62;;-1:-1:-1;;;;;;1304:12178:15;;3782:36:12;3778:74;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;3866:34:12;;:19;;;1304:12178:15;3866:34:12;3862:71;;4267:19;4289:13;4318:53;1304:12178:15;4038:218:12;4267:35;1304:12178:15;4038:218:12;1304:12178:15;;:::i;:::-;3866:12:12;1304:12178:15;;4038:218:12;1304:12178:15;;;4038:218:12;;;1304:12178:15;;;4038:218:12;;;1304:12178:15;;4038:218:12;4289:13;:::i;4267:35::-;4318:53;4038:218;1304:12178:15;4318:53:12;;;;;:::i;:::-;;;;1500:62:0:o;3862:71:12:-;3909:24;;;3671:1;3909:24;;3671:1;3909:24;3706:62;3746:22;;;3671:1;3746:22;;3671:1;3746:22;3650:46;3682:14;;;3671:1;3682:14;;3671:1;3682:14;1304:12178:15;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;1506:2;1304:12178;;1506:2;1304:12178;;;;:::o;:::-;-1:-1:-1;;1304:12178:15;;;;;;;;:::o;4470:442::-;;4673:13;;4669:49;;4745:17;;4744:30;4745:17;;;:::i;:::-;4744:30;:::i;:::-;1304:12178;;;;;;;;;4833:17;;;4470:442;:::o;4669:49::-;-1:-1:-1;4696:10:15;;;;4685:1;;4688:30::o;1304:12178::-;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;;;:::o;3706:324::-;;;3895:13;;3891:37;;3955:17;;3954:30;3955:17;;;:::i;3954:30::-;1304:12178;;;;;;;;;3706:324;:::o;3891:37::-;3910:18;3907:1;3910:18;:::o;1796:162:0:-;1710:6;1304:12178:15;-1:-1:-1;;;;;1304:12178:15;735:10:7;1855:23:0;1851:101;;1796:162::o;1851:101::-;1901:40;;;1710:6;1901:40;735:10:7;1901:40:0;1304:12178:15;;1710:6:0;1901:40;1795:473:11;1304:12178:15;;;;1924:53:11;;1795:473;1991:26;;;1304:12178:15;1987:69:11;;1795:473;2070:19;;;1304:12178:15;2066:53:11;;1795:473;2231:22;;590:6;1304:12178:15;;;;2206:55:11;;1795:473::o;2066:53::-;590:6;2091:28;;;;2066:53;;1987:69;2019:37;526:6;2019:37;1987:69;;;1924:53;453:6;;-1:-1:-1;1924:53:11;;2575:307:8;2702:7;1304:12178:15;;2702:18:8;2698:86;;2702:7;1899:1;;2575:307::o;2698:86::-;2743:30;;;-1:-1:-1;2743:30:8;;-1:-1:-1;2743:30:8;1304:12178:15;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;590:6:11;;;1304:12178:15;;;;;:::o;1506:2::-;;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;1304:12178;;;;;;;:::i;:::-;1506:2;;;-1:-1:-1;1506:2:15;;;;:::o;:::-;1304:12178;1506:2;:::o;:::-;;;;;;1304:12178;;1506:2;;;;;;;;:::i;8618:3181::-;;;;;;8979:19;;;1304:12178;;;;;;;;5340:12:12;1304:12178:15;;;;;;;8979:19;9013:27;453:6:11;3770:27;;3769:34;9008:71:15;;-1:-1:-1;;;;;1304:12178:15;;2003:42;9106:21;;;1304:12178;;;9216:1262;;;;590:6:11;4384:27;;4383:34;9291:68:15;;9449:21;9488:12;;;9484:42;;9613:37;;;;:::i;:::-;9589:61;;;;;9729:28;9725:64;;9216:1262;10537:41;;10592:9;;;:46;;;;9216:1262;10588:252;;;9216:1262;1506:2;11092:63;1506:2;-1:-1:-1;1506:2:15;10935:34;1506:2;;;;;;;:::i;11092:63::-;11279:94;;;;;11290:52;;;;;;;;;;;;:::i;:::-;11279:94;;11387:8;11383:40;;1304:12178;;-1:-1:-1;;;;;1304:12178:15;;;;11521:53;;1304:12178;11521:53;;;1304:12178;11521:53;:::i;:::-;;;;11632:8;;;:39;;;11279:94;11628:143;;11279:94;11781:11;;;;;;8618:3181;:::o;11628:143::-;11751:8;;;:::i;:::-;11628:143;;;;;;;;11632:39;-1:-1:-1;;;;;;1304:12178:15;;11644:27;;11632:39;;11383:40;1304:12178;;-1:-1:-1;;;11404:19:15;;1304:12178;11404:19;1304:12178;11404:19;;;;:::i;11279:94::-;11345:28;;;;;;;;;;;;:::i;:::-;11279:94;;;10588:252;10671:24;;;;;;;1304:12178;;-1:-1:-1;;;10671:24:15;;1304:12178;10671:24;1304:12178;10671:24;1304:12178;10671:24;;;;;;;;-1:-1:-1;10671:24:15;;590:6:11;10671:24:15;;11092:63;10671:24;;;;;10588:252;590:6:11;;1506:2:15;10713:19;;10709:121;;10588:252;;;;;;;;;;;10709:121;10935:34;10795:19;;;10788:27;10795:19;10772:43;10795:19;;:::i;10788:27::-;10772:43;;:::i;:::-;10709:121;;;;10671:24;;;;;;;;;;;;;;:::i;:::-;;;;10592:46;526:6:11;4090:36;4089:43;;;-1:-1:-1;10592:46:15;;;9216:1262;9885:35;;;;;;;;1304:12178;;-1:-1:-1;;;9885:35:15;;9909:10;9885:35;;;1304:12178;;9885:35;1304:12178;;;9885:35;;;;;;;;-1:-1:-1;9885:35:15;;;9216:1262;9875:45;10007:37;9875:45;10007:37;;;:::i;:::-;9983:61;;;10123:28;;;10119:66;;10314:7;10453:13;10307:4;;9909:10;10314:7;;:::i;:::-;10453:13;;;:::i;:::-;9216:1262;;9885:35;;;;;;;;;;;;;;;:::i;:::-;;;;;12063:502;;;12249:13;;12245:62;;12333:30;12334:17;;;;;:::i;12333:30::-;1304:12178;;;;;;;;;12467:18;;;12463:96;;12063:502;;:::o;12463:96::-;12508:40;;;12261:1;12508:40;;1304:12178;;;;12261:1;12508:40;12245:62;12278:18;;;12261:1;12278:18;:::o;1618:188:6:-;1304:12178:15;;-1:-1:-1;;;1745:53:6;;;;-1:-1:-1;;;;;1304:12178:15;;;1745:53:6;;;1304:12178:15;;;;;;;;;;;;;;;;;1745:53:6;;;;;;;1304:12178:15;1745:53:6;:::i;:::-;;:::i;1304:12178:15:-;;344:2:10;1304:12178:15;;;;;;;:::o;3146:225:6:-;;-1:-1:-1;;;;;1304:12178:15;;;3146:225:6;3265:39;;;;;1304:12178:15;;-1:-1:-1;;;3265:39:6;;3289:4;3265:39;;;1304:12178:15;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;3265:39:6;;1304:12178:15;;3265:39:6;;;;;;;-1:-1:-1;3265:39:6;;;3146:225;3343:20;1304:12178:15;;;;;;;3343:20:6;;;:::i;3265:39::-;;;;;1304:12178:15;3265:39:6;1304:12178:15;3265:39:6;;;;;;;:::i;:::-;;;;;7658:500:12;;7769:1;1304:12178:15;;7751:19:12;7747:91;;7880:77;;;7992:19;8044:33;7992:37;1304:12178:15;7992:19:12;;1304:12178:15;;;;;;;;5340:12:12;1304:12178:15;;;;;;;7992:19:12;1304:12178:15;;;;-1:-1:-1;;;;;;1304:12178:15;;3075:153:11;7992:37:12;-1:-1:-1;;;;;;1304:12178:15;;;8044:33:12;-1:-1:-1;;;;;;1304:12178:15;;8044:33:12;8040:112;;7658:500;;:::o;8040:112::-;-1:-1:-1;;;;8100:41:12;-1:-1:-1;;;;;1304:12178:15;7769:1:12;1304:12178:15;-1:-1:-1;;;;;;1304:12178:15;;;;-1:-1:-1;8100:41:12;7747:91;1304:12178:15;;-1:-1:-1;;;7779:59:12;;1304:12178:15;7769:1:12;7779:59;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;7779:59:12;;;1524:1476:10;1506:2:15;1524:1476:10;1506:2:15;;;:::i;:::-;1915::10;1304:12178:15;;1899:18:10;1895:180;;2338:13;2350:1;2333:637;2386:15;2358:26;1304:12178:15;;2358:26:10;:::i;:::-;2353:31;;;;344:2;2444:217;;;;1724:66:15;;;2444:217:10;;2679:20;2675:285;;2386:15;;;;;;:::i;:::-;2338:13;;;;2675:285;2719:171;;;1524:1476;:::o;2353:31::-;;;;1524:1476;:::o;1895:180::-;1304:12178:15;;-1:-1:-1;;;1940:124:10;;1304:12178:15;1940:124:10;;;1304:12178:15;;1915:2:10;1304:12178:15;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;1940:124:10;;;12934:546:15;;;;;;;13152:238;;;;13204:42;;;;1304:12178;-1:-1:-1;;;;;1304:12178:15;;13204:42;;;;:::i;:::-;;13264:14;13260:45;;13404:69;13152:238;;1304:12178;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;13404:69;12934:546::o;13260:45::-;13287:18;;;13204:42;13287:18;;13204:42;13287:18;13152:238;1304:12178;;-1:-1:-1;;;1328:43:6;;;;-1:-1:-1;;;;;1304:12178:15;;1328:43:6;;;1304:12178:15;;;;;;;13404:69;;1304:12178;1328:43:6;;;1304:12178:15;;;;1328:43:6;;1304:12178:15;;1328:43:6;;;;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;1328:43:6;:::i;:::-;13152:238:15;;8370:720:6;;-1:-1:-1;8507:421:6;8370:720;8507:421;;;;;;;;;;;;-1:-1:-1;8507:421:6;;8942:15;;-1:-1:-1;;;;;;1304:12178:15;;8960:26:6;:31;8942:68;8938:146;;8370:720;:::o;8938:146::-;-1:-1:-1;;;;9033:40:6;;;-1:-1:-1;;;;;1304:12178:15;;;;9033:40:6;1304:12178:15;;;9033:40:6;8942:68;9009:1;8994:16;;8942:68;;5084:380;1304:12178:15;;-1:-1:-1;;;5199:47:6;;;;;;;-1:-1:-1;;;;;1304:12178:15;;5199:47:6;;;1304:12178:15;;;;;;;;;5199:47:6;;;1304:12178:15;;;;-1:-1:-1;;5199:47:6;1304:12178:15;;5199:47:6;:::i;:::-;9770:199;;;;;;;-1:-1:-1;9770:199:6;;;;9985:80;;5084:380;-1:-1:-1;5261:45:6;;-1:-1:-1;5261:45:6;5257:201;;5084:380;;;:::o;5257:201::-;1304:12178:15;;-1:-1:-1;;;5199:47:6;5349:43;;;-1:-1:-1;;;;;1304:12178:15;;;5199:47:6;5349:43;;1304:12178:15;5389:1:6;1304:12178:15;;;;5434:12:6;;5349:43;;;1304:12178:15;;;;5349:43:6;1304:12178:15;5349:43:6;;;:::i;9985:80::-;9997:15;;;-1:-1:-1;9997:15:6;;-1:-1:-1;5261:45:6;-1:-1:-1;;;;;1304:12178:15;;10015:26:6;:30;;9997:67;9985:80;;;9997:67;10063:1;5261:45;10048:16;;9997:67;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122076617063a96bad71bfcd134d654760133c1ba640afac43490299d5245590b95e64736f6c634300081b0033","offset":6889}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x7d45a07dbebea496777d3160017ff7dc302342f489e9df699a819a11c5267a5b","blockNumber":"23992610","transactionIndex":"209","deployer":"0x7779FFB11d50fcEae8E533b611b5CB5A1C1db3d4"},"sources":{"src/VaultDepositooorV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { IERC20Metadata as IERC20 } from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { ReentrancyGuard } from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport { VaultDepositManager } from \"@fun-contracts/Utils/VaultDepositManager.sol\";\nimport { VaultConfigLib } from \"@fun-contracts/Utils/VaultConfigLib.sol\";\nimport { Replacer } from \"@fun-contracts/Utils/Replacer.sol\";\n\n/**\n * @title VaultDepositooorV2\n * @author dextracker\n * @notice Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter\n *         that require deposit amounts to be exact multiples of a tick size.\n *\n * @dev Tick sizes are passed per-call (not per-vault) because different assets on the same vault\n *      may have different tick sizes. For example, Lighter uses:\n *      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)\n *      - USDC: tickSize = 1 (no rounding needed)\n *\n *      The depositWithTick() function:\n *      - Rounds deposit amounts DOWN to the nearest tick size\n *      - Refunds any dust (remainder) to a specified recipient\n *      - Supports both ERC20 tokens and native ETH\n */\ncontract VaultDepositooorV2 is VaultDepositManager, ReentrancyGuard {\n    using SafeERC20 for IERC20;\n    using VaultConfigLib for uint40;\n    using Replacer for bytes;\n\n    uint256 constant EIGHTEEN = 18;\n\n    // ============ Constants ============\n\n    /// @notice Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime\n    uint256 public constant AMOUNT_PLACEHOLDER = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffdeadbeef;\n    bytes32 public constant AMOUNT_PLACEHOLDER_BYTES32 = bytes32(AMOUNT_PLACEHOLDER);\n\n    /// @notice Address used to represent native ETH (follows common convention)\n    address public constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n\n    // ============ Errors ============\n\n    error InvalidTickSize();\n    error InvalidDustRecipient();\n    error AmountBelowMinimumTick(uint256 amount, uint256 tickSize);\n    error DustRefundFailed();\n\n    // ============ Events ============\n\n    /// @notice Emitted when dust is refunded to a recipient after tick rounding\n    /// @param recipient The address receiving the dust\n    /// @param token The token address (or NATIVE_TOKEN for ETH)\n    /// @param dust The amount of dust refunded\n    /// @param originalAmount The original amount before rounding\n    /// @param depositedAmount The amount actually deposited after rounding\n    event DustRefunded(\n        address indexed recipient,\n        address indexed token,\n        uint256 dust,\n        uint256 originalAmount,\n        uint256 depositedAmount\n    );\n\n    // ============ Constructor ============\n\n    /// @notice Initializes the contract and optionally transfers ownership\n    /// @param initialOwner Address to transfer ownership to, or address(0) to keep deployer as owner\n    constructor(address initialOwner) VaultDepositManager(initialOwner) { }\n\n    /// @notice Allow contract to receive native ETH\n    receive() external payable { }\n\n    // ============ Pure Helper Functions ============\n\n    /**\n     * @notice Calculate the tick-rounded amount and dust for a given input\n     * @dev Pure function for off-chain calculation and validation\n     * @param amount The input amount to round\n     * @param tickSize The tick size to round down to\n     * @return roundedAmount The amount rounded down to nearest tick\n     * @return dust The remainder (amount - roundedAmount)\n     */\n    function calculateTickRounding(\n        uint256 amount,\n        uint256 tickSize\n    )\n        external\n        pure\n        returns (uint256 roundedAmount, uint256 dust)\n    {\n        if (tickSize == 0) return (amount, 0);\n        roundedAmount = (amount / tickSize) * tickSize;\n        dust = amount - roundedAmount;\n    }\n\n    /**\n     * @notice Check if an amount is valid for a given tick size\n     * @dev Returns true if amount >= tickSize (at least one full tick)\n     * @param amount The amount to check\n     * @param tickSize The tick size requirement\n     * @return isValid True if amount is valid for the tick size\n     * @return roundedAmount The amount that would be deposited\n     * @return dust The amount that would be refunded as dust\n     */\n    function validateAmountForTick(\n        uint256 amount,\n        uint256 tickSize\n    )\n        external\n        pure\n        returns (bool isValid, uint256 roundedAmount, uint256 dust)\n    {\n        if (tickSize == 0) return (amount > 0, amount, 0);\n        roundedAmount = (amount / tickSize) * tickSize;\n        dust = amount - roundedAmount;\n        isValid = roundedAmount > 0; // roundedAmount is always 0 or a multiple of tickSize\n    }\n\n    /**\n     * @notice Get the minimum deposit amount for a given tick size\n     * @dev The minimum is exactly one tick\n     * @param tickSize The tick size\n     * @return minAmount The minimum valid deposit amount\n     */\n    function getMinimumDepositForTick(uint256 tickSize) external pure returns (uint256 minAmount) {\n        return tickSize == 0 ? 1 : tickSize;\n    }\n\n    // ============ Core Deposit Functions ============\n\n    /**\n     * @notice Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault\n     * @dev Standard deposit function without tick rounding - same as V1\n     *\n     * @param token The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH\n     * @param vault The registered vault contract to deposit into\n     * @param callData The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position\n     * @param minAmountOut Minimum token/ETH balance required for deposit (slippage/frontrunning protection)\n     *\n     * @return returnData The raw bytes returned from the vault's deposit function call\n     */\n    function deposit(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut\n    )\n        external\n        nonReentrant\n        returns (bytes memory returnData)\n    {\n        return _deposit(token, vault, callData, minAmountOut, 0, address(0));\n    }\n\n    /**\n     * @notice Deposit with tick-size rounding for protocols requiring exact amount multiples\n     * @dev Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.\n     *\n     *      Why tickSize is per-call (not per-vault):\n     *      Different assets on the same vault may have different tick sizes.\n     *      Example: Lighter ETH tickSize=10^10, USDC tickSize=1\n     *\n     *      Example with tickSize = 10^10 (Lighter ETH):\n     *      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)\n     *      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)\n     *      - Dust refunded: 123 wei\n     *\n     * @param token The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH\n     * @param vault The registered vault contract to deposit into\n     * @param callData The vault function calldata containing AMOUNT_PLACEHOLDER\n     * @param minAmountOut Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)\n     * @param tickSize The tick size to round down to (must be > 0)\n     * @param dustRecipient Address to receive any dust from rounding (must not be zero)\n     *\n     * @return returnData The raw bytes returned from the vault's deposit function call\n     */\n    function depositWithTick(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut,\n        uint256 tickSize,\n        address dustRecipient\n    )\n        external\n        nonReentrant\n        returns (bytes memory returnData)\n    {\n        if (tickSize == 0) revert InvalidTickSize();\n        if (dustRecipient == address(0)) revert InvalidDustRecipient();\n\n        return _deposit(token, vault, callData, minAmountOut, tickSize, dustRecipient);\n    }\n\n    // ============ Internal Functions ============\n\n    /**\n     * @notice Internal deposit implementation supporting optional tick rounding\n     * @param token The token to deposit\n     * @param vault The vault to deposit into\n     * @param callData The calldata with AMOUNT_PLACEHOLDER\n     * @param minAmountOut Minimum amount after rounding\n     * @param tickSize Tick size for rounding (0 = no rounding)\n     * @param dustRecipient Recipient of dust (ignored if tickSize == 0)\n     */\n    function _deposit(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut,\n        uint256 tickSize,\n        address dustRecipient\n    )\n        internal\n        returns (bytes memory returnData)\n    {\n        // Load vault configuration from storage (single SLOAD for 5 bytes)\n        uint40 packedConfig = vaultConfigs[vault];\n        if (!packedConfig.isRegistered()) revert VaultNotRegisteredForDeposit();\n\n        bool isNative = token == NATIVE_TOKEN;\n        uint256 balance;\n        uint256 depositAmount;\n        uint256 dust;\n\n        if (isNative) {\n            // Check vault supports native ETH\n            if (!packedConfig.allowsNative()) revert VaultDoesNotSupportNative();\n\n            // For native ETH, check this contract's ETH balance\n            balance = address(this).balance;\n            if (balance == 0) revert NoETHInContract();\n\n            // Apply tick rounding if specified\n            (depositAmount, dust) = _applyTickRounding(balance, tickSize);\n\n            // Slippage protection (checked AFTER rounding)\n            if (depositAmount < minAmountOut) revert InsufficientETHAmount();\n        } else {\n            // For ERC20 tokens - get caller's balance\n            balance = IERC20(token).balanceOf(msg.sender);\n\n            // Apply tick rounding if specified\n            (depositAmount, dust) = _applyTickRounding(balance, tickSize);\n\n            // Slippage protection (checked AFTER rounding)\n            if (depositAmount < minAmountOut) revert InsufficientTokenAmount();\n\n            // Pull tokens from caller to this contract\n            IERC20(token).safeTransferFrom(msg.sender, address(this), balance);\n\n            // Approve vault to spend only the deposit amount (not dust)\n            IERC20(token).safeIncreaseAllowance(vault, depositAmount);\n        }\n\n        // Prepare amount for calldata injection\n        uint256 amountForCalldata = depositAmount;\n        if (!isNative && packedConfig.requiresConversion()) {\n            uint8 decimals = IERC20(token).decimals();\n            if (decimals < EIGHTEEN) {\n                amountForCalldata = depositAmount * 10 ** (EIGHTEEN - decimals);\n            }\n        }\n\n        // Validate that the function selector in callData is allowed for this vault\n        _validateSelector(vault, callData);\n\n        // Replace AMOUNT_PLACEHOLDER in calldata with the actual/scaled amount\n        bytes memory modifiedCallData = callData.replace(AMOUNT_PLACEHOLDER_BYTES32, amountForCalldata);\n\n        // Execute the vault deposit call with modified calldata\n        (bool success, bytes memory data) =\n            isNative ? vault.call{ value: depositAmount }(modifiedCallData) : vault.call(modifiedCallData);\n        if (!success) revert DepositFailed(data);\n\n        // Emit event with the actual deposited amount (in native token decimals)\n        emit FunMediatedDeposit(vault, token, depositAmount, data);\n\n        // Refund dust to recipient if any\n        if (dust > 0 && dustRecipient != address(0)) {\n            _refundDust(token, dustRecipient, dust, balance, depositAmount, isNative);\n        }\n\n        return data;\n    }\n\n    /**\n     * @notice Apply tick rounding to an amount\n     * @param amount The original amount\n     * @param tickSize The tick size (0 = no rounding)\n     * @return depositAmount The rounded amount to deposit\n     * @return dust The dust to refund\n     */\n    function _applyTickRounding(\n        uint256 amount,\n        uint256 tickSize\n    )\n        internal\n        pure\n        returns (uint256 depositAmount, uint256 dust)\n    {\n        if (tickSize == 0) {\n            return (amount, 0);\n        }\n\n        depositAmount = (amount / tickSize) * tickSize;\n        dust = amount - depositAmount;\n\n        // Ensure we have at least one tick worth\n        if (depositAmount == 0) {\n            revert AmountBelowMinimumTick(amount, tickSize);\n        }\n    }\n\n    /**\n     * @notice Refund dust to recipient\n     * @param token The token (or NATIVE_TOKEN)\n     * @param recipient The dust recipient\n     * @param dust The dust amount\n     * @param originalAmount The original amount before rounding\n     * @param depositedAmount The amount deposited after rounding\n     * @param isNative Whether this is native ETH\n     */\n    function _refundDust(\n        address token,\n        address recipient,\n        uint256 dust,\n        uint256 originalAmount,\n        uint256 depositedAmount,\n        bool isNative\n    )\n        internal\n    {\n        if (isNative) {\n            (bool refundSuccess,) = payable(recipient).call{ value: dust }(\"\");\n            if (!refundSuccess) revert DustRefundFailed();\n        } else {\n            IERC20(token).safeTransfer(recipient, dust);\n        }\n        emit DustRefunded(recipient, token, dust, originalAmount, depositedAmount);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            // bubble errors\n            if iszero(success) {\n                let ptr := mload(0x40)\n                returndatacopy(ptr, 0, returndatasize())\n                revert(ptr, returndatasize())\n            }\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        bool success;\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"src/Utils/VaultDepositManager.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { Ownable } from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport { VaultWrapperErrors } from \"@fun-contracts/Utils/VaultWrapperErrors.sol\";\nimport { VaultWrapperEvents } from \"@fun-contracts/Utils/VaultWrapperEvents.sol\";\nimport { VaultConfigLib } from \"@fun-contracts/Utils/VaultConfigLib.sol\";\n\n/**\n * @title VaultDepositManager\n * @notice Admin functions for managing vault registrations\n * @dev Inherited by VaultDepositWrapper to separate admin logic from core deposit functionality\n *      All storage and constants must be defined here or in parent contracts for inheritance\n */\nabstract contract VaultDepositManager is Ownable, VaultWrapperErrors, VaultWrapperEvents {\n    using VaultConfigLib for uint40;\n    using VaultConfigLib for VaultConfigLib.VaultConfig;\n    // ============ Storage Layout ============\n    // Must be defined in inheritance order to match VaultDepositWrapper\n\n    /// @notice Mapping from vault address to packed configuration\n    /// @dev Each vault uses 5 bytes of storage (uint40) containing:\n    ///      - Configuration flags (isRegistered, convertTo18Decimals, allowsNative)\n    ///      - Allowed function selector (bytes4)\n    ///\n    ///      Gas savings vs separate mappings:\n    ///      - registerVault(): Single SSTORE for both config and selector\n    ///      - deposit(): Single SLOAD + library calls for validation\n    ///\n    ///      Security: Function selector whitelist prevents arbitrary function calls\n    mapping(address => uint40) public vaultConfigs;\n\n    // ============ Constructor ============\n\n    /// @notice Initialize with the specified owner\n    /// @param initialOwner The address to set as owner. If zero address, deployer becomes owner\n    constructor(address initialOwner) Ownable(initialOwner == address(0) ? msg.sender : initialOwner) {\n        // Owner is set directly in Ownable constructor - no additional transfer needed\n    }\n\n    // ============ Admin Functions ============\n\n    /**\n     * @notice Register a vault to enable deposits through this contract\n     * @dev Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().\n     *      The vault cannot be re-registered without first removing it.\n     *\n     *      Security: Only the specified function selector can be called on this vault\n     *      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)\n     *\n     * @param vault The address of the vault contract to register\n     * @param vaultABI The deposit method signature (e.g., \"deposit(uint256,address)\")\n     *        Emitted in VaultRegistered event for off-chain reference only\n     * @param allowedFunctionSelector The single function selector that can be called on this vault\n     *        Only this function can be invoked through the VaultWrapper for security\n     * @param convertTo18Decimals Whether to scale token amounts to 18 decimals before injecting into calldata\n     *        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)\n     *        - false: Amount is used as-is in token's native decimals\n     * @param allowsNative Whether this vault accepts native ETH deposits\n     *        - true: Vault can receive ETH via NATIVE_TOKEN parameter\n     *        - false: Vault only accepts ERC20 tokens\n     */\n    function registerVault(\n        address vault,\n        string memory vaultABI,\n        bytes4 allowedFunctionSelector,\n        bool convertTo18Decimals,\n        bool allowsNative\n    )\n        external\n        onlyOwner\n    {\n        if (vault == address(0)) revert InvalidVault();\n        if (bytes(vaultABI).length == 0) revert EmptyMethodSignature();\n        if (allowedFunctionSelector == bytes4(0)) revert InvalidFunctionSelector();\n        if (vaultConfigs[vault].isRegistered()) revert VaultAlreadyRegistered();\n\n        // Create configuration struct and pack it\n        VaultConfigLib.VaultConfig memory config = VaultConfigLib.VaultConfig({\n            isRegistered: true,\n            convertTo18Decimals: convertTo18Decimals,\n            allowsNative: allowsNative,\n            allowedSelector: allowedFunctionSelector\n        });\n\n        vaultConfigs[vault] = config.pack();\n\n        emit VaultRegistered(vault, vaultABI, convertTo18Decimals);\n    }\n\n    /**\n     * @notice Remove a vault from the registry, preventing future deposits\n     * @dev Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,\n     *      it only prevents new deposits through this contract.\n     *\n     * @param vault The address of the vault to remove from the registry\n     */\n    function removeVault(address vault) external onlyOwner {\n        if (!vaultConfigs[vault].isRegistered()) revert VaultNotRegistered();\n\n        delete vaultConfigs[vault];\n\n        emit VaultRemoved(vault);\n    }\n\n    /**\n     * @notice Update the allowed function selector for a registered vault\n     * @dev Only callable by owner. Changes the function that can be called on this vault.\n     * @param vault The registered vault address\n     * @param newSelector The new function selector to allow\n     */\n    function updateAllowedSelector(address vault, bytes4 newSelector) external onlyOwner {\n        if (!vaultConfigs[vault].isRegistered()) revert VaultNotRegistered();\n        if (newSelector == bytes4(0)) revert InvalidFunctionSelector();\n\n        vaultConfigs[vault] = vaultConfigs[vault].updateSelector(newSelector);\n\n        emit SelectorUpdated(vault, newSelector);\n    }\n\n    // ============ View Helpers ============\n\n    /**\n     * @notice Check if a vault is registered\n     * @param vault The vault address to check\n     * @return True if the vault is registered, false otherwise\n     */\n    function isVaultRegistered(address vault) external view returns (bool) {\n        return vaultConfigs[vault].isRegistered();\n    }\n\n    /**\n     * @notice Check if a vault requires 18-decimal conversion\n     * @param vault The vault address to check\n     * @return True if the vault requires amount scaling to 18 decimals, false otherwise\n     */\n    function vaultRequires18Decimals(address vault) external view returns (bool) {\n        return vaultConfigs[vault].requiresConversion();\n    }\n\n    /**\n     * @notice Check if a vault allows native ETH deposits\n     * @param vault The vault address to check\n     * @return True if the vault accepts native ETH, false if it only accepts ERC20 tokens\n     */\n    function vaultAllowsNative(address vault) external view returns (bool) {\n        return vaultConfigs[vault].allowsNative();\n    }\n\n    /**\n     * @notice Get the allowed function selector for a vault\n     * @param vault The vault address to check\n     * @return The function selector that can be called on this vault\n     */\n    function getAllowedSelector(address vault) external view returns (bytes4) {\n        return vaultConfigs[vault].extractSelector();\n    }\n\n    /**\n     * @notice Get the full vault configuration\n     * @param vault The vault address to check\n     * @return config The unpacked vault configuration\n     */\n    function getVaultConfig(address vault) external view returns (VaultConfigLib.VaultConfig memory config) {\n        return vaultConfigs[vault].unpack();\n    }\n\n    /**\n     * @notice Internal function to validate function selector before vault call\n     * @dev Extracts the function selector from calldata and checks if it matches the allowed selector\n     * @param vault The vault address being called\n     * @param callData The calldata being sent to the vault\n     */\n    function _validateSelector(address vault, bytes memory callData) internal view {\n        if (callData.length < 4) revert InvalidCalldata(\"Calldata too short for function selector\");\n\n        bytes4 calledSelector;\n        assembly {\n            calledSelector := mload(add(callData, 0x20))\n        }\n\n        bytes4 allowedSelector = vaultConfigs[vault].extractSelector();\n\n        if (calledSelector != allowedSelector) {\n            revert SelectorNotAllowed(vault, calledSelector);\n        }\n    }\n}\n"},"src/Utils/VaultConfigLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultConfigLib\n * @notice Library for packing vault configuration and function selectors into efficient storage\n * @dev Packs vault config flags and function selector into a single uint40 (5 bytes) for gas efficiency\n */\nlibrary VaultConfigLib {\n    // ============ Constants ============\n\n    /// @notice Bit flags for vault configuration\n    uint40 constant FLAG_IS_REGISTERED = 1 << 0; // bit 0: 0x01\n    uint40 constant FLAG_CONVERT_TO_18_DECIMALS = 1 << 1; // bit 1: 0x02\n    uint40 constant FLAG_ALLOWS_NATIVE = 1 << 2; // bit 2: 0x04\n\n    /// @notice Bitmasks for extracting packed data\n    uint40 constant SELECTOR_MASK = 0xFFFFFFFF00; // bits 8-39 for full bytes4 selector\n    uint40 constant FLAGS_MASK = 0x00000000FF; // bits 0-7 for flags\n\n    // ============ Structs ============\n\n    /**\n     * @notice Unpacked vault configuration struct\n     * @param isRegistered Whether the vault is registered for deposits\n     * @param convertTo18Decimals Whether to scale amounts to 18 decimals in calldata\n     * @param allowsNative Whether the vault accepts native ETH deposits\n     * @param allowedSelector The function selector that can be called on this vault\n     */\n    struct VaultConfig {\n        bool isRegistered;\n        bool convertTo18Decimals;\n        bool allowsNative;\n        bytes4 allowedSelector;\n    }\n\n    // ============ Packing Functions ============\n\n    /**\n     * @notice Pack a VaultConfig struct into a uint40\n     * @dev Bit layout:\n     *      - bits 0-7: flags (isRegistered, convertTo18Decimals, allowsNative)\n     *      - bits 8-39: function selector (32 bits)\n     * @param config The vault configuration to pack\n     * @return packed The packed configuration as uint40\n     */\n    function pack(VaultConfig memory config) internal pure returns (uint40 packed) {\n        // Pack flags into lower 8 bits\n        if (config.isRegistered) packed |= FLAG_IS_REGISTERED;\n        if (config.convertTo18Decimals) packed |= FLAG_CONVERT_TO_18_DECIMALS;\n        if (config.allowsNative) packed |= FLAG_ALLOWS_NATIVE;\n\n        // Pack function selector into upper 32 bits (shift left by 8 bits)\n        packed |= (uint40(uint32(config.allowedSelector)) << 8);\n    }\n\n    /**\n     * @notice Unpack a uint40 into a VaultConfig struct\n     * @param packed The packed configuration as uint40\n     * @return config The unpacked vault configuration\n     */\n    function unpack(uint40 packed) internal pure returns (VaultConfig memory config) {\n        config.isRegistered = (packed & FLAG_IS_REGISTERED) != 0;\n        config.convertTo18Decimals = (packed & FLAG_CONVERT_TO_18_DECIMALS) != 0;\n        config.allowsNative = (packed & FLAG_ALLOWS_NATIVE) != 0;\n        config.allowedSelector = bytes4(uint32((packed & SELECTOR_MASK) >> 8));\n    }\n\n    // ============ Utility Functions ============\n\n    /**\n     * @notice Extract just the function selector from packed config\n     * @param packed The packed configuration\n     * @return selector The function selector\n     */\n    function extractSelector(uint40 packed) internal pure returns (bytes4 selector) {\n        selector = bytes4(uint32((packed & SELECTOR_MASK) >> 8));\n    }\n\n    /**\n     * @notice Extract just the flags from packed config\n     * @param packed The packed configuration\n     * @return flags The configuration flags as uint8\n     */\n    function extractFlags(uint40 packed) internal pure returns (uint8 flags) {\n        flags = uint8(packed & FLAGS_MASK);\n    }\n\n    /**\n     * @notice Check if vault is registered\n     * @param packed The packed configuration\n     * @return True if vault is registered\n     */\n    function isRegistered(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_IS_REGISTERED) != 0;\n    }\n\n    /**\n     * @notice Check if vault requires 18 decimal conversion\n     * @param packed The packed configuration\n     * @return True if conversion to 18 decimals is required\n     */\n    function requiresConversion(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_CONVERT_TO_18_DECIMALS) != 0;\n    }\n\n    /**\n     * @notice Check if vault allows native ETH\n     * @param packed The packed configuration\n     * @return True if native ETH is allowed\n     */\n    function allowsNative(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_ALLOWS_NATIVE) != 0;\n    }\n\n    /**\n     * @notice Update just the function selector in packed config\n     * @param packed The current packed configuration\n     * @param newSelector The new function selector\n     * @return updated The updated packed configuration\n     */\n    function updateSelector(uint40 packed, bytes4 newSelector) internal pure returns (uint40 updated) {\n        // Keep existing flags, replace selector\n        uint40 flags = packed & FLAGS_MASK;\n        uint40 packedSelector = (uint40(uint32(newSelector)) << 8);\n        updated = flags | packedSelector;\n    }\n}\n"},"src/Utils/Replacer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { VaultWrapperErrors } from \"@fun-contracts/Utils/VaultWrapperErrors.sol\";\n\n/**\n * @title Replacer\n * @notice Library for replacing placeholder values in calldata\n * @dev Gas-optimized calldata manipulation using assembly\n */\nlibrary Replacer {\n    uint256 constant THIRTY_TWO = 32;\n\n    /**\n     * @notice Replace the first occurrence of a placeholder with the actual amount\n     * @dev This function performs a search through calldata looking for the placeholder value.\n     *\n     *      Gas Optimization & Safety:\n     *      - Skips the first 4 bytes (function selector) to prevent accidental selector replacement\n     *      - Iterates in 32-byte chunks (not byte-by-byte) since calldata is padded to 32-byte words\n     *      - Only replaces the FIRST occurrence; additional placeholders are ignored\n     *\n     *      Example of why we skip the selector:\n     *      If selector is 0xAAAAAAFF and placeholder starts with 0xFF, we could accidentally\n     *      replace part of the selector, corrupting the function call.\n     *\n     *      Gas Cost: ~4,700 + (placeholder_position × 250) gas, O(params) complexity\n     *\n     * @param callData The original calldata containing the placeholder\n     * @param placeholder The placeholder value to search for (as bytes32)\n     * @param amount The actual amount to inject (may be scaled to 18 decimals by caller)\n     * @return result The modified calldata with placeholder replaced by amount\n     */\n    function replace(\n        bytes calldata callData,\n        bytes32 placeholder,\n        uint256 amount\n    )\n        internal\n        pure\n        returns (bytes memory result)\n    {\n        result = bytes(callData);\n        bytes32 amountBytes = bytes32(amount);\n\n        // Ensure callData is long enough: 4 bytes selector + at least 32 bytes for one parameter\n        if (result.length < 36) {\n            revert VaultWrapperErrors\n                .InvalidCalldata(\"Call data is too short to include selector and at least one parameter\");\n        }\n\n        // Search for placeholder starting after the 4-byte function selector\n        // Iterate in 32-byte chunks since calldata parameters are padded to full words\n        // Start at byte 4 (after selector), increment by 32 bytes each iteration\n        for (uint256 i = 4; i <= result.length - THIRTY_TWO; i += THIRTY_TWO) {\n            bytes32 chunk;\n            assembly {\n                // Load 32 bytes at position (i + 32)\n                // The +32 accounts for the length prefix in memory layout\n                chunk := mload(add(result, add(i, THIRTY_TWO)))\n            }\n\n            if (chunk == placeholder) {\n                assembly {\n                    // Replace the placeholder with the actual amount\n                    mstore(add(result, add(i, THIRTY_TWO)), amountBytes)\n                }\n                break; // Only replace first occurrence\n            }\n        }\n\n        return result;\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"src/Utils/VaultWrapperErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultWrapperErrors\n * @notice Custom errors for VaultDepositWrapper contract\n * @dev Centralized error definitions for gas-efficient reverts\n */\ninterface VaultWrapperErrors {\n    /// @notice Thrown when calldata is too short to contain a valid placeholder\n    /// @dev Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)\n    /// @param reason Descriptive message explaining why the calldata is invalid\n    error InvalidCalldata(string reason);\n\n    /// @notice Thrown when trying to register the zero address as a vault\n    error InvalidVault();\n\n    /// @notice Thrown when vault ABI/method signature is empty\n    error EmptyMethodSignature();\n\n    /// @notice Thrown when trying to register a vault that is already registered\n    error VaultAlreadyRegistered();\n\n    /// @notice Thrown when trying to remove a vault that is not registered\n    error VaultNotRegistered();\n\n    /// @notice Thrown when deposit is called for an unregistered vault\n    error VaultNotRegisteredForDeposit();\n\n    /// @notice Thrown when no ETH is present in contract for native token deposit\n    error NoETHInContract();\n\n    /// @notice Thrown when ETH balance is below minimum amount out (slippage protection)\n    error InsufficientETHAmount();\n\n    /// @notice Thrown when token balance is below minimum amount out (slippage protection)\n    error InsufficientTokenAmount();\n\n    /// @notice Thrown when the vault deposit call fails\n    /// @param returnData The raw revert data returned by the failed vault call\n    error DepositFailed(bytes returnData);\n\n    /// @notice Thrown when attempting native ETH deposit to a vault that doesn't support it\n    error VaultDoesNotSupportNative();\n\n    /// @notice Thrown when trying to register a vault with an invalid (zero) function selector\n    error InvalidFunctionSelector();\n\n    /// @notice Thrown when trying to call a function selector that is not allowed for the vault\n    /// @param vault The vault address that was called\n    /// @param selector The function selector that was attempted\n    error SelectorNotAllowed(address vault, bytes4 selector);\n}\n"},"src/Utils/VaultWrapperEvents.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultWrapperEvents\n * @notice Events emitted by VaultDepositWrapper contract\n * @dev Centralized event definitions for tracking contract state changes\n */\ninterface VaultWrapperEvents {\n    /// @notice Emitted when a new vault is registered by the owner\n    /// @param vault The address of the registered vault contract\n    /// @param methodSignature The deposit method signature for this vault (documentation only, not used for\n    /// replacement) @param convertTo18Decimals Whether amounts should be converted to 18 decimals for this vault (used\n    /// in deposit logic)\n    event VaultRegistered(address indexed vault, string methodSignature, bool convertTo18Decimals);\n\n    /// @notice Emitted when a vault is removed from the registry by the owner\n    /// @param vault The address of the vault that was removed\n    event VaultRemoved(address indexed vault);\n\n    /// @notice Emitted when this contract successfully deposits tokens into a vault\n    /// @param vault The vault contract that received the deposit\n    /// @param token The ERC20 token that was deposited\n    /// @param amount The actual amount of tokens deposited (in token's native decimals)\n    /// @param returnData The raw return data from the vault's deposit function call\n    event FunMediatedDeposit(address indexed vault, address indexed token, uint256 amount, bytes returnData);\n\n    /// @notice Emitted when a vault's allowed function selector is updated\n    /// @param vault The vault whose selector was updated\n    /// @param newSelector The new function selector\n    event SelectorUpdated(address indexed vault, bytes4 indexed newSelector);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.27+commit.40a35a09","compilerSettings":{"debug":{"revertStrings":"debug"},"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":100,"enabled":true},"evmVersion":"cancun","remappings":["@CREATE3/=src/CREATE3/","@forge-std/=dependencies/forge-std-1.11.0/src/","@fun-contracts/=src/","@fun-test-contracts/=test/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.4.0/","@solmate/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/","CREATE3-1.0.0/=dependencies/CREATE3-1.0.0/","forge-std/=dependencies/forge-std-1.11.0/src/","@openzeppelin-contracts-5.4.0/=dependencies/@openzeppelin-contracts-5.4.0/","forge-std-1.11.0/=dependencies/forge-std-1.11.0/src/","solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/"]},"name":"VaultDepositooorV2","fullyQualifiedName":"src/VaultDepositooorV2.sol:VaultDepositooorV2"},"abi":[{"type":"constructor","inputs":[{"name":"initialOwner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AmountBelowMinimumTick","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}]},{"name":"DepositFailed","type":"error","inputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}]},{"name":"DustRefundFailed","type":"error","inputs":[]},{"name":"EmptyMethodSignature","type":"error","inputs":[]},{"name":"InsufficientETHAmount","type":"error","inputs":[]},{"name":"InsufficientTokenAmount","type":"error","inputs":[]},{"name":"InvalidCalldata","type":"error","inputs":[{"name":"reason","type":"string","internalType":"string"}]},{"name":"InvalidDustRecipient","type":"error","inputs":[]},{"name":"InvalidFunctionSelector","type":"error","inputs":[]},{"name":"InvalidTickSize","type":"error","inputs":[]},{"name":"InvalidVault","type":"error","inputs":[]},{"name":"NoETHInContract","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"SelectorNotAllowed","type":"error","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"selector","type":"bytes4","internalType":"bytes4"}]},{"name":"VaultAlreadyRegistered","type":"error","inputs":[]},{"name":"VaultDoesNotSupportNative","type":"error","inputs":[]},{"name":"VaultNotRegistered","type":"error","inputs":[]},{"name":"VaultNotRegisteredForDeposit","type":"error","inputs":[]},{"name":"DustRefunded","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"dust","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"originalAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"depositedAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FunMediatedDeposit","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"returnData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SelectorUpdated","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"newSelector","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"VaultRegistered","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"methodSignature","type":"string","indexed":false,"internalType":"string"},{"name":"convertTo18Decimals","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"VaultRemoved","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"AMOUNT_PLACEHOLDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"AMOUNT_PLACEHOLDER_BYTES32","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"NATIVE_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"calculateTickRounding","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"roundedAmount","type":"uint256","internalType":"uint256"},{"name":"dust","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"deposit","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"vault","type":"address","internalType":"address"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"depositWithTick","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"vault","type":"address","internalType":"address"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"},{"name":"dustRecipient","type":"address","internalType":"address"}],"outputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"getAllowedSelector","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"view"},{"name":"getMinimumDepositForTick","type":"function","inputs":[{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"minAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"getVaultConfig","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"config","type":"tuple","components":[{"name":"isRegistered","type":"bool","internalType":"bool"},{"name":"convertTo18Decimals","type":"bool","internalType":"bool"},{"name":"allowsNative","type":"bool","internalType":"bool"},{"name":"allowedSelector","type":"bytes4","internalType":"bytes4"}],"internalType":"struct VaultConfigLib.VaultConfig"}],"stateMutability":"view"},{"name":"isVaultRegistered","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"registerVault","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"vaultABI","type":"string","internalType":"string"},{"name":"allowedFunctionSelector","type":"bytes4","internalType":"bytes4"},{"name":"convertTo18Decimals","type":"bool","internalType":"bool"},{"name":"allowsNative","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeVault","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAllowedSelector","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newSelector","type":"bytes4","internalType":"bytes4"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"validateAmountForTick","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"isValid","type":"bool","internalType":"bool"},{"name":"roundedAmount","type":"uint256","internalType":"uint256"},{"name":"dust","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"vaultAllowsNative","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"vaultConfigs","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"vaultRequires18Decimals","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.27+commit.40a35a09"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"initialOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tickSize","type":"uint256"}],"name":"AmountBelowMinimumTick","type":"error"},{"inputs":[{"internalType":"bytes","name":"returnData","type":"bytes"}],"name":"DepositFailed","type":"error"},{"inputs":[],"name":"DustRefundFailed","type":"error"},{"inputs":[],"name":"EmptyMethodSignature","type":"error"},{"inputs":[],"name":"InsufficientETHAmount","type":"error"},{"inputs":[],"name":"InsufficientTokenAmount","type":"error"},{"inputs":[{"internalType":"string","name":"reason","type":"string"}],"name":"InvalidCalldata","type":"error"},{"inputs":[],"name":"InvalidDustRecipient","type":"error"},{"inputs":[],"name":"InvalidFunctionSelector","type":"error"},{"inputs":[],"name":"InvalidTickSize","type":"error"},{"inputs":[],"name":"InvalidVault","type":"error"},{"inputs":[],"name":"NoETHInContract","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes4","name":"selector","type":"bytes4"}],"name":"SelectorNotAllowed","type":"error"},{"inputs":[],"name":"VaultAlreadyRegistered","type":"error"},{"inputs":[],"name":"VaultDoesNotSupportNative","type":"error"},{"inputs":[],"name":"VaultNotRegistered","type":"error"},{"inputs":[],"name":"VaultNotRegisteredForDeposit","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"dust","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"originalAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"depositedAmount","type":"uint256"}],"name":"DustRefunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"returnData","type":"bytes"}],"name":"FunMediatedDeposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":true,"internalType":"bytes4","name":"newSelector","type":"bytes4"}],"name":"SelectorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"string","name":"methodSignature","type":"string"},{"indexed":false,"internalType":"bool","name":"convertTo18Decimals","type":"bool"}],"name":"VaultRegistered","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"}],"name":"VaultRemoved","type":"event"},{"inputs":[],"name":"AMOUNT_PLACEHOLDER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AMOUNT_PLACEHOLDER_BYTES32","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NATIVE_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tickSize","type":"uint256"}],"name":"calculateTickRounding","outputs":[{"internalType":"uint256","name":"roundedAmount","type":"uint256"},{"internalType":"uint256","name":"dust","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"bytes","name":"returnData","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"internalType":"uint256","name":"tickSize","type":"uint256"},{"internalType":"address","name":"dustRecipient","type":"address"}],"name":"depositWithTick","outputs":[{"internalType":"bytes","name":"returnData","type":"bytes"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"getAllowedSelector","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tickSize","type":"uint256"}],"name":"getMinimumDepositForTick","outputs":[{"internalType":"uint256","name":"minAmount","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"getVaultConfig","outputs":[{"components":[{"internalType":"bool","name":"isRegistered","type":"bool"},{"internalType":"bool","name":"convertTo18Decimals","type":"bool"},{"internalType":"bool","name":"allowsNative","type":"bool"},{"internalType":"bytes4","name":"allowedSelector","type":"bytes4"}],"internalType":"struct VaultConfigLib.VaultConfig","name":"config","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"isVaultRegistered","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"string","name":"vaultABI","type":"string"},{"internalType":"bytes4","name":"allowedFunctionSelector","type":"bytes4"},{"internalType":"bool","name":"convertTo18Decimals","type":"bool"},{"internalType":"bool","name":"allowsNative","type":"bool"}],"name":"registerVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"removeVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"},{"internalType":"bytes4","name":"newSelector","type":"bytes4"}],"name":"updateAllowedSelector","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tickSize","type":"uint256"}],"name":"validateAmountForTick","outputs":[{"internalType":"bool","name":"isValid","type":"bool"},{"internalType":"uint256","name":"roundedAmount","type":"uint256"},{"internalType":"uint256","name":"dust","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"vaultAllowsNative","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"vaultConfigs","outputs":[{"internalType":"uint40","name":"","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"vault","type":"address"}],"name":"vaultRequires18Decimals","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"author":"dextracker","details":"Tick sizes are passed per-call (not per-vault) because different assets on the same vault      may have different tick sizes. For example, Lighter uses:      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)      - USDC: tickSize = 1 (no rounding needed)      The depositWithTick() function:      - Rounds deposit amounts DOWN to the nearest tick size      - Refunds any dust (remainder) to a specified recipient      - Supports both ERC20 tokens and native ETH","errors":{"DepositFailed(bytes)":[{"params":{"returnData":"The raw revert data returned by the failed vault call"}}],"InvalidCalldata(string)":[{"details":"Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)","params":{"reason":"Descriptive message explaining why the calldata is invalid"}}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"SelectorNotAllowed(address,bytes4)":[{"params":{"selector":"The function selector that was attempted","vault":"The vault address that was called"}}]},"events":{"DustRefunded(address,address,uint256,uint256,uint256)":{"params":{"depositedAmount":"The amount actually deposited after rounding","dust":"The amount of dust refunded","originalAmount":"The original amount before rounding","recipient":"The address receiving the dust","token":"The token address (or NATIVE_TOKEN for ETH)"}},"FunMediatedDeposit(address,address,uint256,bytes)":{"params":{"amount":"The actual amount of tokens deposited (in token's native decimals)","returnData":"The raw return data from the vault's deposit function call","token":"The ERC20 token that was deposited","vault":"The vault contract that received the deposit"}},"SelectorUpdated(address,bytes4)":{"params":{"newSelector":"The new function selector","vault":"The vault whose selector was updated"}},"VaultRegistered(address,string,bool)":{"params":{"convertTo18Decimals":"Whether amounts should be converted to 18 decimals for this vault (used in deposit logic)","methodSignature":"The deposit method signature for this vault (documentation only, not used for","vault":"The address of the registered vault contract"}},"VaultRemoved(address)":{"params":{"vault":"The address of the vault that was removed"}}},"kind":"dev","methods":{"calculateTickRounding(uint256,uint256)":{"details":"Pure function for off-chain calculation and validation","params":{"amount":"The input amount to round","tickSize":"The tick size to round down to"},"returns":{"dust":"The remainder (amount - roundedAmount)","roundedAmount":"The amount rounded down to nearest tick"}},"constructor":{"params":{"initialOwner":"Address to transfer ownership to, or address(0) to keep deployer as owner"}},"deposit(address,address,bytes,uint256)":{"details":"Standard deposit function without tick rounding - same as V1","params":{"callData":"The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position","minAmountOut":"Minimum token/ETH balance required for deposit (slippage/frontrunning protection)","token":"The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH","vault":"The registered vault contract to deposit into"},"returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"details":"Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.      Why tickSize is per-call (not per-vault):      Different assets on the same vault may have different tick sizes.      Example: Lighter ETH tickSize=10^10, USDC tickSize=1      Example with tickSize = 10^10 (Lighter ETH):      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)      - Dust refunded: 123 wei","params":{"callData":"The vault function calldata containing AMOUNT_PLACEHOLDER","dustRecipient":"Address to receive any dust from rounding (must not be zero)","minAmountOut":"Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)","tickSize":"The tick size to round down to (must be > 0)","token":"The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH","vault":"The registered vault contract to deposit into"},"returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}},"getAllowedSelector(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"The function selector that can be called on this vault"}},"getMinimumDepositForTick(uint256)":{"details":"The minimum is exactly one tick","params":{"tickSize":"The tick size"},"returns":{"minAmount":"The minimum valid deposit amount"}},"getVaultConfig(address)":{"params":{"vault":"The vault address to check"},"returns":{"config":"The unpacked vault configuration"}},"isVaultRegistered(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault is registered, false otherwise"}},"owner()":{"details":"Returns the address of the current owner."},"registerVault(address,string,bytes4,bool,bool)":{"details":"Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().      The vault cannot be re-registered without first removing it.      Security: Only the specified function selector can be called on this vault      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)","params":{"allowedFunctionSelector":"The single function selector that can be called on this vault        Only this function can be invoked through the VaultWrapper for security","allowsNative":"Whether this vault accepts native ETH deposits        - true: Vault can receive ETH via NATIVE_TOKEN parameter        - false: Vault only accepts ERC20 tokens","convertTo18Decimals":"Whether to scale token amounts to 18 decimals before injecting into calldata        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)        - false: Amount is used as-is in token's native decimals","vault":"The address of the vault contract to register","vaultABI":"The deposit method signature (e.g., \"deposit(uint256,address)\")        Emitted in VaultRegistered event for off-chain reference only"}},"removeVault(address)":{"details":"Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,      it only prevents new deposits through this contract.","params":{"vault":"The address of the vault to remove from the registry"}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"updateAllowedSelector(address,bytes4)":{"details":"Only callable by owner. Changes the function that can be called on this vault.","params":{"newSelector":"The new function selector to allow","vault":"The registered vault address"}},"validateAmountForTick(uint256,uint256)":{"details":"Returns true if amount >= tickSize (at least one full tick)","params":{"amount":"The amount to check","tickSize":"The tick size requirement"},"returns":{"dust":"The amount that would be refunded as dust","isValid":"True if amount is valid for the tick size","roundedAmount":"The amount that would be deposited"}},"vaultAllowsNative(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault accepts native ETH, false if it only accepts ERC20 tokens"}},"vaultRequires18Decimals(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault requires amount scaling to 18 decimals, false otherwise"}}},"title":"VaultDepositooorV2","version":1},"userdoc":{"errors":{"DepositFailed(bytes)":[{"notice":"Thrown when the vault deposit call fails"}],"EmptyMethodSignature()":[{"notice":"Thrown when vault ABI/method signature is empty"}],"InsufficientETHAmount()":[{"notice":"Thrown when ETH balance is below minimum amount out (slippage protection)"}],"InsufficientTokenAmount()":[{"notice":"Thrown when token balance is below minimum amount out (slippage protection)"}],"InvalidCalldata(string)":[{"notice":"Thrown when calldata is too short to contain a valid placeholder"}],"InvalidFunctionSelector()":[{"notice":"Thrown when trying to register a vault with an invalid (zero) function selector"}],"InvalidVault()":[{"notice":"Thrown when trying to register the zero address as a vault"}],"NoETHInContract()":[{"notice":"Thrown when no ETH is present in contract for native token deposit"}],"SelectorNotAllowed(address,bytes4)":[{"notice":"Thrown when trying to call a function selector that is not allowed for the vault"}],"VaultAlreadyRegistered()":[{"notice":"Thrown when trying to register a vault that is already registered"}],"VaultDoesNotSupportNative()":[{"notice":"Thrown when attempting native ETH deposit to a vault that doesn't support it"}],"VaultNotRegistered()":[{"notice":"Thrown when trying to remove a vault that is not registered"}],"VaultNotRegisteredForDeposit()":[{"notice":"Thrown when deposit is called for an unregistered vault"}]},"events":{"DustRefunded(address,address,uint256,uint256,uint256)":{"notice":"Emitted when dust is refunded to a recipient after tick rounding"},"FunMediatedDeposit(address,address,uint256,bytes)":{"notice":"Emitted when this contract successfully deposits tokens into a vault"},"SelectorUpdated(address,bytes4)":{"notice":"Emitted when a vault's allowed function selector is updated"},"VaultRegistered(address,string,bool)":{"notice":"Emitted when a new vault is registered by the owner"},"VaultRemoved(address)":{"notice":"Emitted when a vault is removed from the registry by the owner"}},"kind":"user","methods":{"AMOUNT_PLACEHOLDER()":{"notice":"Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime"},"NATIVE_TOKEN()":{"notice":"Address used to represent native ETH (follows common convention)"},"calculateTickRounding(uint256,uint256)":{"notice":"Calculate the tick-rounded amount and dust for a given input"},"constructor":{"notice":"Initializes the contract and optionally transfers ownership"},"deposit(address,address,bytes,uint256)":{"notice":"Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault"},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"notice":"Deposit with tick-size rounding for protocols requiring exact amount multiples"},"getAllowedSelector(address)":{"notice":"Get the allowed function selector for a vault"},"getMinimumDepositForTick(uint256)":{"notice":"Get the minimum deposit amount for a given tick size"},"getVaultConfig(address)":{"notice":"Get the full vault configuration"},"isVaultRegistered(address)":{"notice":"Check if a vault is registered"},"registerVault(address,string,bytes4,bool,bool)":{"notice":"Register a vault to enable deposits through this contract"},"removeVault(address)":{"notice":"Remove a vault from the registry, preventing future deposits"},"updateAllowedSelector(address,bytes4)":{"notice":"Update the allowed function selector for a registered vault"},"validateAmountForTick(uint256,uint256)":{"notice":"Check if an amount is valid for a given tick size"},"vaultAllowsNative(address)":{"notice":"Check if a vault allows native ETH deposits"},"vaultConfigs(address)":{"notice":"Mapping from vault address to packed configuration"},"vaultRequires18Decimals(address)":{"notice":"Check if a vault requires 18-decimal conversion"}},"notice":"Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter         that require deposit amounts to be exact multiples of a tick size.","version":1}},"settings":{"compilationTarget":{"src/VaultDepositooorV2.sol":"VaultDepositooorV2"},"debug":{"revertStrings":"debug"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":100},"remappings":[":@CREATE3/=src/CREATE3/",":@forge-std/=dependencies/forge-std-1.11.0/src/",":@fun-contracts/=src/",":@fun-test-contracts/=test/",":@openzeppelin-contracts-5.4.0/=dependencies/@openzeppelin-contracts-5.4.0/",":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.4.0/",":@solmate/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/",":CREATE3-1.0.0/=dependencies/CREATE3-1.0.0/",":forge-std-1.11.0/=dependencies/forge-std-1.11.0/src/",":forge-std/=dependencies/forge-std-1.11.0/src/",":solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/"],"viaIR":true},"sources":{"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol":{"keccak256":"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d","license":"MIT","urls":["bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100","dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d"]},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol":{"keccak256":"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc","license":"MIT","urls":["bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037","dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ"]},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol":{"keccak256":"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44","license":"MIT","urls":["bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d","dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF"]},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol":{"keccak256":"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2","license":"MIT","urls":["bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303","dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV"]},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f","license":"MIT","urls":["bzz-raw://f95ee0bbd4dd3ac730d066ba3e785ded4565e890dbec2fa7d3b9fe3bad9d0d6e","dweb:/ipfs/QmSLr6bHkPFWT7ntj34jmwfyskpwo97T9jZUrk5sz3sdtR"]},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5","license":"MIT","urls":["bzz-raw://8150ceb4ac947e8a442b2a9c017e01e880b2be2dd958f1fa9bc405f4c5a86508","dweb:/ipfs/QmbcBmFX66AY6Kbhnd5gx7zpkgqnUafo43XnmayAM7zVdB"]},"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol":{"keccak256":"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3","license":"MIT","urls":["bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a","dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"]},"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","license":"MIT","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"]},"src/Utils/Replacer.sol":{"keccak256":"0x6a9a46ee21f2d5dc82d0de5f7a8383c6e10770a422566febbd424c9f190c0a8a","license":"MIT","urls":["bzz-raw://6afa8de9b6dbbdc28d20da59aaa903583f5e01d715f050e84b7372abbb4506ac","dweb:/ipfs/QmPT8gRG9f3DbKVyTbBChqpBrgCpxnzPbzEvPbAFmiFh4H"]},"src/Utils/VaultConfigLib.sol":{"keccak256":"0xc02fcf314428103195b2c61b5d3703c8e9ee23969565190cdf1c3fa4973ed926","license":"MIT","urls":["bzz-raw://91a99fcef41d251c733820c54045394ee47449a6ffc2b24ce58cf0ab282a93e1","dweb:/ipfs/QmfDYc3FySGTEJBiY6UeCX4gfA3Yru97dyUopM5KrXQnXy"]},"src/Utils/VaultDepositManager.sol":{"keccak256":"0x15078e0157b0bfe0d7ff7272209c42d08765d5a8ae4f92f724589f9102154b90","license":"MIT","urls":["bzz-raw://53afb775be47b541389cffcf65021f08094c572870a18bc5a0942654e4f5d34a","dweb:/ipfs/QmdYJDcbFfDTQSkGC7uKELX2XcQk1boqzmuK45RuyDKkHL"]},"src/Utils/VaultWrapperErrors.sol":{"keccak256":"0x554a4c5082591ba76cb4a977593a9ac01c760badb9e213f1088c638cf9614078","license":"MIT","urls":["bzz-raw://d382c930426da297d2e6bc824305b5730dbb09575545f82bb4b7c24d0cda476c","dweb:/ipfs/QmRwMHrVEePyGMLrt5ZQwn1eWEJc9PXfJRS8LG5GT3XEBV"]},"src/Utils/VaultWrapperEvents.sol":{"keccak256":"0x90d3e0391e3cfb5ab25f2d82f9ada85a1438a563ac185ed13c93746e197e4ebb","license":"MIT","urls":["bzz-raw://2a83a8c2e6d070b5d7177ee16916bf4c88c70791bc83e3e436d8f5b8dc26cd20","dweb:/ipfs/QmRuPhyhEibsp3sqT9gnzEe2CG8tamjQ6hoC8B9yE86PN5"]},"src/VaultDepositooorV2.sol":{"keccak256":"0x633474cf97f316048c8786578e51c25be936686542c634fb2cfbf05495f611a5","license":"MIT","urls":["bzz-raw://82bbf389f29dfd2d7f117de65f8221147c13bbfde571b796eb2029d4bf0845f1","dweb:/ipfs/QmbqP8FsKmsBxHK3bLfdtmcBnVCZC2dy6eM6LnNk1rUXWk"]}},"version":1},"storageLayout":{"types":{"t_uint40":{"label":"uint40","encoding":"inplace","numberOfBytes":"5"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_uint40)":{"key":"t_address","label":"mapping(address => uint40)","value":"t_uint40","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"},{"slot":"1","type":"t_mapping(t_address,t_uint40)","astId":1290,"label":"vaultConfigs","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"},{"slot":"2","type":"t_uint256","astId":846,"label":"_status","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"InvalidVault()":[{"notice":"Thrown when trying to register the zero address as a vault"}],"NoETHInContract()":[{"notice":"Thrown when no ETH is present in contract for native token deposit"}],"DepositFailed(bytes)":[{"notice":"Thrown when the vault deposit call fails"}],"VaultNotRegistered()":[{"notice":"Thrown when trying to remove a vault that is not registered"}],"EmptyMethodSignature()":[{"notice":"Thrown when vault ABI/method signature is empty"}],"InsufficientETHAmount()":[{"notice":"Thrown when ETH balance is below minimum amount out (slippage protection)"}],"InvalidCalldata(string)":[{"notice":"Thrown when calldata is too short to contain a valid placeholder"}],"VaultAlreadyRegistered()":[{"notice":"Thrown when trying to register a vault that is already registered"}],"InsufficientTokenAmount()":[{"notice":"Thrown when token balance is below minimum amount out (slippage protection)"}],"InvalidFunctionSelector()":[{"notice":"Thrown when trying to register a vault with an invalid (zero) function selector"}],"VaultDoesNotSupportNative()":[{"notice":"Thrown when attempting native ETH deposit to a vault that doesn't support it"}],"VaultNotRegisteredForDeposit()":[{"notice":"Thrown when deposit is called for an unregistered vault"}],"SelectorNotAllowed(address,bytes4)":[{"notice":"Thrown when trying to call a function selector that is not allowed for the vault"}]},"events":{"VaultRemoved(address)":{"notice":"Emitted when a vault is removed from the registry by the owner"},"SelectorUpdated(address,bytes4)":{"notice":"Emitted when a vault's allowed function selector is updated"},"VaultRegistered(address,string,bool)":{"notice":"Emitted when a new vault is registered by the owner"},"FunMediatedDeposit(address,address,uint256,bytes)":{"notice":"Emitted when this contract successfully deposits tokens into a vault"},"DustRefunded(address,address,uint256,uint256,uint256)":{"notice":"Emitted when dust is refunded to a recipient after tick rounding"}},"notice":"Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter         that require deposit amounts to be exact multiples of a tick size.","methods":{"constructor":{"notice":"Initializes the contract and optionally transfers ownership"},"NATIVE_TOKEN()":{"notice":"Address used to represent native ETH (follows common convention)"},"AMOUNT_PLACEHOLDER()":{"notice":"Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime"},"removeVault(address)":{"notice":"Remove a vault from the registry, preventing future deposits"},"vaultConfigs(address)":{"notice":"Mapping from vault address to packed configuration"},"getVaultConfig(address)":{"notice":"Get the full vault configuration"},"isVaultRegistered(address)":{"notice":"Check if a vault is registered"},"vaultAllowsNative(address)":{"notice":"Check if a vault allows native ETH deposits"},"getAllowedSelector(address)":{"notice":"Get the allowed function selector for a vault"},"vaultRequires18Decimals(address)":{"notice":"Check if a vault requires 18-decimal conversion"},"getMinimumDepositForTick(uint256)":{"notice":"Get the minimum deposit amount for a given tick size"},"updateAllowedSelector(address,bytes4)":{"notice":"Update the allowed function selector for a registered vault"},"calculateTickRounding(uint256,uint256)":{"notice":"Calculate the tick-rounded amount and dust for a given input"},"deposit(address,address,bytes,uint256)":{"notice":"Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault"},"validateAmountForTick(uint256,uint256)":{"notice":"Check if an amount is valid for a given tick size"},"registerVault(address,string,bytes4,bool,bool)":{"notice":"Register a vault to enable deposits through this contract"},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"notice":"Deposit with tick-size rounding for protocols requiring exact amount multiples"}},"version":1},"devdoc":{"kind":"dev","title":"VaultDepositooorV2","author":"dextracker","errors":{"DepositFailed(bytes)":[{"params":{"returnData":"The raw revert data returned by the failed vault call"}}],"InvalidCalldata(string)":[{"params":{"reason":"Descriptive message explaining why the calldata is invalid"},"details":"Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)"}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"SelectorNotAllowed(address,bytes4)":[{"params":{"vault":"The vault address that was called","selector":"The function selector that was attempted"}}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"events":{"VaultRemoved(address)":{"params":{"vault":"The address of the vault that was removed"}},"SelectorUpdated(address,bytes4)":{"params":{"vault":"The vault whose selector was updated","newSelector":"The new function selector"}},"VaultRegistered(address,string,bool)":{"params":{"vault":"The address of the registered vault contract","methodSignature":"The deposit method signature for this vault (documentation only, not used for","convertTo18Decimals":"Whether amounts should be converted to 18 decimals for this vault (used in deposit logic)"}},"FunMediatedDeposit(address,address,uint256,bytes)":{"params":{"token":"The ERC20 token that was deposited","vault":"The vault contract that received the deposit","amount":"The actual amount of tokens deposited (in token's native decimals)","returnData":"The raw return data from the vault's deposit function call"}},"DustRefunded(address,address,uint256,uint256,uint256)":{"params":{"dust":"The amount of dust refunded","token":"The token address (or NATIVE_TOKEN for ETH)","recipient":"The address receiving the dust","originalAmount":"The original amount before rounding","depositedAmount":"The amount actually deposited after rounding"}}},"details":"Tick sizes are passed per-call (not per-vault) because different assets on the same vault      may have different tick sizes. For example, Lighter uses:      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)      - USDC: tickSize = 1 (no rounding needed)      The depositWithTick() function:      - Rounds deposit amounts DOWN to the nearest tick size      - Refunds any dust (remainder) to a specified recipient      - Supports both ERC20 tokens and native ETH","methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"params":{"initialOwner":"Address to transfer ownership to, or address(0) to keep deployer as owner"}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"removeVault(address)":{"params":{"vault":"The address of the vault to remove from the registry"},"details":"Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,      it only prevents new deposits through this contract."},"getVaultConfig(address)":{"params":{"vault":"The vault address to check"},"returns":{"config":"The unpacked vault configuration"}},"isVaultRegistered(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault is registered, false otherwise"}},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"vaultAllowsNative(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault accepts native ETH, false if it only accepts ERC20 tokens"}},"getAllowedSelector(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"The function selector that can be called on this vault"}},"vaultRequires18Decimals(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault requires amount scaling to 18 decimals, false otherwise"}},"getMinimumDepositForTick(uint256)":{"params":{"tickSize":"The tick size"},"details":"The minimum is exactly one tick","returns":{"minAmount":"The minimum valid deposit amount"}},"updateAllowedSelector(address,bytes4)":{"params":{"vault":"The registered vault address","newSelector":"The new function selector to allow"},"details":"Only callable by owner. Changes the function that can be called on this vault."},"calculateTickRounding(uint256,uint256)":{"params":{"amount":"The input amount to round","tickSize":"The tick size to round down to"},"details":"Pure function for off-chain calculation and validation","returns":{"dust":"The remainder (amount - roundedAmount)","roundedAmount":"The amount rounded down to nearest tick"}},"deposit(address,address,bytes,uint256)":{"params":{"token":"The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH","vault":"The registered vault contract to deposit into","callData":"The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position","minAmountOut":"Minimum token/ETH balance required for deposit (slippage/frontrunning protection)"},"details":"Standard deposit function without tick rounding - same as V1","returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}},"validateAmountForTick(uint256,uint256)":{"params":{"amount":"The amount to check","tickSize":"The tick size requirement"},"details":"Returns true if amount >= tickSize (at least one full tick)","returns":{"dust":"The amount that would be refunded as dust","isValid":"True if amount is valid for the tick size","roundedAmount":"The amount that would be deposited"}},"registerVault(address,string,bytes4,bool,bool)":{"params":{"vault":"The address of the vault contract to register","vaultABI":"The deposit method signature (e.g., \"deposit(uint256,address)\")        Emitted in VaultRegistered event for off-chain reference only","allowsNative":"Whether this vault accepts native ETH deposits        - true: Vault can receive ETH via NATIVE_TOKEN parameter        - false: Vault only accepts ERC20 tokens","convertTo18Decimals":"Whether to scale token amounts to 18 decimals before injecting into calldata        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)        - false: Amount is used as-is in token's native decimals","allowedFunctionSelector":"The single function selector that can be called on this vault        Only this function can be invoked through the VaultWrapper for security"},"details":"Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().      The vault cannot be re-registered without first removing it.      Security: Only the specified function selector can be called on this vault      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)"},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"params":{"token":"The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH","vault":"The registered vault contract to deposit into","callData":"The vault function calldata containing AMOUNT_PLACEHOLDER","tickSize":"The tick size to round down to (must be > 0)","minAmountOut":"Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)","dustRecipient":"Address to receive any dust from rounding (must not be zero)"},"details":"Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.      Why tickSize is per-call (not per-vault):      Different assets on the same vault may have different tick sizes.      Example: Lighter ETH tickSize=10^10, USDC tickSize=1      Example with tickSize = 10^10 (Lighter ETH):      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)      - Dust refunded: 123 wei","returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}}},"version":1},"sourceIds":{"src/Utils/Replacer.sol":{"id":10},"src/VaultDepositooorV2.sol":{"id":15},"src/Utils/VaultConfigLib.sol":{"id":11},"src/Utils/VaultWrapperErrors.sol":{"id":13},"src/Utils/VaultWrapperEvents.sol":{"id":14},"src/Utils/VaultDepositManager.sol":{"id":12},"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol":{"id":7},"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol":{"id":3},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol":{"id":2},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol":{"id":4},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol":{"id":1},"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol":{"id":8},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol":{"id":6},"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol":{"id":9},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol":{"id":5}},"additionalInput":null,"stdJsonInput":{"sources":{"src/Utils/Replacer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { VaultWrapperErrors } from \"@fun-contracts/Utils/VaultWrapperErrors.sol\";\n\n/**\n * @title Replacer\n * @notice Library for replacing placeholder values in calldata\n * @dev Gas-optimized calldata manipulation using assembly\n */\nlibrary Replacer {\n    uint256 constant THIRTY_TWO = 32;\n\n    /**\n     * @notice Replace the first occurrence of a placeholder with the actual amount\n     * @dev This function performs a search through calldata looking for the placeholder value.\n     *\n     *      Gas Optimization & Safety:\n     *      - Skips the first 4 bytes (function selector) to prevent accidental selector replacement\n     *      - Iterates in 32-byte chunks (not byte-by-byte) since calldata is padded to 32-byte words\n     *      - Only replaces the FIRST occurrence; additional placeholders are ignored\n     *\n     *      Example of why we skip the selector:\n     *      If selector is 0xAAAAAAFF and placeholder starts with 0xFF, we could accidentally\n     *      replace part of the selector, corrupting the function call.\n     *\n     *      Gas Cost: ~4,700 + (placeholder_position × 250) gas, O(params) complexity\n     *\n     * @param callData The original calldata containing the placeholder\n     * @param placeholder The placeholder value to search for (as bytes32)\n     * @param amount The actual amount to inject (may be scaled to 18 decimals by caller)\n     * @return result The modified calldata with placeholder replaced by amount\n     */\n    function replace(\n        bytes calldata callData,\n        bytes32 placeholder,\n        uint256 amount\n    )\n        internal\n        pure\n        returns (bytes memory result)\n    {\n        result = bytes(callData);\n        bytes32 amountBytes = bytes32(amount);\n\n        // Ensure callData is long enough: 4 bytes selector + at least 32 bytes for one parameter\n        if (result.length < 36) {\n            revert VaultWrapperErrors\n                .InvalidCalldata(\"Call data is too short to include selector and at least one parameter\");\n        }\n\n        // Search for placeholder starting after the 4-byte function selector\n        // Iterate in 32-byte chunks since calldata parameters are padded to full words\n        // Start at byte 4 (after selector), increment by 32 bytes each iteration\n        for (uint256 i = 4; i <= result.length - THIRTY_TWO; i += THIRTY_TWO) {\n            bytes32 chunk;\n            assembly {\n                // Load 32 bytes at position (i + 32)\n                // The +32 accounts for the length prefix in memory layout\n                chunk := mload(add(result, add(i, THIRTY_TWO)))\n            }\n\n            if (chunk == placeholder) {\n                assembly {\n                    // Replace the placeholder with the actual amount\n                    mstore(add(result, add(i, THIRTY_TWO)), amountBytes)\n                }\n                break; // Only replace first occurrence\n            }\n        }\n\n        return result;\n    }\n}\n"},"src/VaultDepositooorV2.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { IERC20Metadata as IERC20 } from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport { SafeERC20 } from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { ReentrancyGuard } from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport { VaultDepositManager } from \"@fun-contracts/Utils/VaultDepositManager.sol\";\nimport { VaultConfigLib } from \"@fun-contracts/Utils/VaultConfigLib.sol\";\nimport { Replacer } from \"@fun-contracts/Utils/Replacer.sol\";\n\n/**\n * @title VaultDepositooorV2\n * @author dextracker\n * @notice Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter\n *         that require deposit amounts to be exact multiples of a tick size.\n *\n * @dev Tick sizes are passed per-call (not per-vault) because different assets on the same vault\n *      may have different tick sizes. For example, Lighter uses:\n *      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)\n *      - USDC: tickSize = 1 (no rounding needed)\n *\n *      The depositWithTick() function:\n *      - Rounds deposit amounts DOWN to the nearest tick size\n *      - Refunds any dust (remainder) to a specified recipient\n *      - Supports both ERC20 tokens and native ETH\n */\ncontract VaultDepositooorV2 is VaultDepositManager, ReentrancyGuard {\n    using SafeERC20 for IERC20;\n    using VaultConfigLib for uint40;\n    using Replacer for bytes;\n\n    uint256 constant EIGHTEEN = 18;\n\n    // ============ Constants ============\n\n    /// @notice Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime\n    uint256 public constant AMOUNT_PLACEHOLDER = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffdeadbeef;\n    bytes32 public constant AMOUNT_PLACEHOLDER_BYTES32 = bytes32(AMOUNT_PLACEHOLDER);\n\n    /// @notice Address used to represent native ETH (follows common convention)\n    address public constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;\n\n    // ============ Errors ============\n\n    error InvalidTickSize();\n    error InvalidDustRecipient();\n    error AmountBelowMinimumTick(uint256 amount, uint256 tickSize);\n    error DustRefundFailed();\n\n    // ============ Events ============\n\n    /// @notice Emitted when dust is refunded to a recipient after tick rounding\n    /// @param recipient The address receiving the dust\n    /// @param token The token address (or NATIVE_TOKEN for ETH)\n    /// @param dust The amount of dust refunded\n    /// @param originalAmount The original amount before rounding\n    /// @param depositedAmount The amount actually deposited after rounding\n    event DustRefunded(\n        address indexed recipient,\n        address indexed token,\n        uint256 dust,\n        uint256 originalAmount,\n        uint256 depositedAmount\n    );\n\n    // ============ Constructor ============\n\n    /// @notice Initializes the contract and optionally transfers ownership\n    /// @param initialOwner Address to transfer ownership to, or address(0) to keep deployer as owner\n    constructor(address initialOwner) VaultDepositManager(initialOwner) { }\n\n    /// @notice Allow contract to receive native ETH\n    receive() external payable { }\n\n    // ============ Pure Helper Functions ============\n\n    /**\n     * @notice Calculate the tick-rounded amount and dust for a given input\n     * @dev Pure function for off-chain calculation and validation\n     * @param amount The input amount to round\n     * @param tickSize The tick size to round down to\n     * @return roundedAmount The amount rounded down to nearest tick\n     * @return dust The remainder (amount - roundedAmount)\n     */\n    function calculateTickRounding(\n        uint256 amount,\n        uint256 tickSize\n    )\n        external\n        pure\n        returns (uint256 roundedAmount, uint256 dust)\n    {\n        if (tickSize == 0) return (amount, 0);\n        roundedAmount = (amount / tickSize) * tickSize;\n        dust = amount - roundedAmount;\n    }\n\n    /**\n     * @notice Check if an amount is valid for a given tick size\n     * @dev Returns true if amount >= tickSize (at least one full tick)\n     * @param amount The amount to check\n     * @param tickSize The tick size requirement\n     * @return isValid True if amount is valid for the tick size\n     * @return roundedAmount The amount that would be deposited\n     * @return dust The amount that would be refunded as dust\n     */\n    function validateAmountForTick(\n        uint256 amount,\n        uint256 tickSize\n    )\n        external\n        pure\n        returns (bool isValid, uint256 roundedAmount, uint256 dust)\n    {\n        if (tickSize == 0) return (amount > 0, amount, 0);\n        roundedAmount = (amount / tickSize) * tickSize;\n        dust = amount - roundedAmount;\n        isValid = roundedAmount > 0; // roundedAmount is always 0 or a multiple of tickSize\n    }\n\n    /**\n     * @notice Get the minimum deposit amount for a given tick size\n     * @dev The minimum is exactly one tick\n     * @param tickSize The tick size\n     * @return minAmount The minimum valid deposit amount\n     */\n    function getMinimumDepositForTick(uint256 tickSize) external pure returns (uint256 minAmount) {\n        return tickSize == 0 ? 1 : tickSize;\n    }\n\n    // ============ Core Deposit Functions ============\n\n    /**\n     * @notice Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault\n     * @dev Standard deposit function without tick rounding - same as V1\n     *\n     * @param token The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH\n     * @param vault The registered vault contract to deposit into\n     * @param callData The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position\n     * @param minAmountOut Minimum token/ETH balance required for deposit (slippage/frontrunning protection)\n     *\n     * @return returnData The raw bytes returned from the vault's deposit function call\n     */\n    function deposit(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut\n    )\n        external\n        nonReentrant\n        returns (bytes memory returnData)\n    {\n        return _deposit(token, vault, callData, minAmountOut, 0, address(0));\n    }\n\n    /**\n     * @notice Deposit with tick-size rounding for protocols requiring exact amount multiples\n     * @dev Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.\n     *\n     *      Why tickSize is per-call (not per-vault):\n     *      Different assets on the same vault may have different tick sizes.\n     *      Example: Lighter ETH tickSize=10^10, USDC tickSize=1\n     *\n     *      Example with tickSize = 10^10 (Lighter ETH):\n     *      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)\n     *      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)\n     *      - Dust refunded: 123 wei\n     *\n     * @param token The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH\n     * @param vault The registered vault contract to deposit into\n     * @param callData The vault function calldata containing AMOUNT_PLACEHOLDER\n     * @param minAmountOut Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)\n     * @param tickSize The tick size to round down to (must be > 0)\n     * @param dustRecipient Address to receive any dust from rounding (must not be zero)\n     *\n     * @return returnData The raw bytes returned from the vault's deposit function call\n     */\n    function depositWithTick(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut,\n        uint256 tickSize,\n        address dustRecipient\n    )\n        external\n        nonReentrant\n        returns (bytes memory returnData)\n    {\n        if (tickSize == 0) revert InvalidTickSize();\n        if (dustRecipient == address(0)) revert InvalidDustRecipient();\n\n        return _deposit(token, vault, callData, minAmountOut, tickSize, dustRecipient);\n    }\n\n    // ============ Internal Functions ============\n\n    /**\n     * @notice Internal deposit implementation supporting optional tick rounding\n     * @param token The token to deposit\n     * @param vault The vault to deposit into\n     * @param callData The calldata with AMOUNT_PLACEHOLDER\n     * @param minAmountOut Minimum amount after rounding\n     * @param tickSize Tick size for rounding (0 = no rounding)\n     * @param dustRecipient Recipient of dust (ignored if tickSize == 0)\n     */\n    function _deposit(\n        address token,\n        address vault,\n        bytes calldata callData,\n        uint256 minAmountOut,\n        uint256 tickSize,\n        address dustRecipient\n    )\n        internal\n        returns (bytes memory returnData)\n    {\n        // Load vault configuration from storage (single SLOAD for 5 bytes)\n        uint40 packedConfig = vaultConfigs[vault];\n        if (!packedConfig.isRegistered()) revert VaultNotRegisteredForDeposit();\n\n        bool isNative = token == NATIVE_TOKEN;\n        uint256 balance;\n        uint256 depositAmount;\n        uint256 dust;\n\n        if (isNative) {\n            // Check vault supports native ETH\n            if (!packedConfig.allowsNative()) revert VaultDoesNotSupportNative();\n\n            // For native ETH, check this contract's ETH balance\n            balance = address(this).balance;\n            if (balance == 0) revert NoETHInContract();\n\n            // Apply tick rounding if specified\n            (depositAmount, dust) = _applyTickRounding(balance, tickSize);\n\n            // Slippage protection (checked AFTER rounding)\n            if (depositAmount < minAmountOut) revert InsufficientETHAmount();\n        } else {\n            // For ERC20 tokens - get caller's balance\n            balance = IERC20(token).balanceOf(msg.sender);\n\n            // Apply tick rounding if specified\n            (depositAmount, dust) = _applyTickRounding(balance, tickSize);\n\n            // Slippage protection (checked AFTER rounding)\n            if (depositAmount < minAmountOut) revert InsufficientTokenAmount();\n\n            // Pull tokens from caller to this contract\n            IERC20(token).safeTransferFrom(msg.sender, address(this), balance);\n\n            // Approve vault to spend only the deposit amount (not dust)\n            IERC20(token).safeIncreaseAllowance(vault, depositAmount);\n        }\n\n        // Prepare amount for calldata injection\n        uint256 amountForCalldata = depositAmount;\n        if (!isNative && packedConfig.requiresConversion()) {\n            uint8 decimals = IERC20(token).decimals();\n            if (decimals < EIGHTEEN) {\n                amountForCalldata = depositAmount * 10 ** (EIGHTEEN - decimals);\n            }\n        }\n\n        // Validate that the function selector in callData is allowed for this vault\n        _validateSelector(vault, callData);\n\n        // Replace AMOUNT_PLACEHOLDER in calldata with the actual/scaled amount\n        bytes memory modifiedCallData = callData.replace(AMOUNT_PLACEHOLDER_BYTES32, amountForCalldata);\n\n        // Execute the vault deposit call with modified calldata\n        (bool success, bytes memory data) =\n            isNative ? vault.call{ value: depositAmount }(modifiedCallData) : vault.call(modifiedCallData);\n        if (!success) revert DepositFailed(data);\n\n        // Emit event with the actual deposited amount (in native token decimals)\n        emit FunMediatedDeposit(vault, token, depositAmount, data);\n\n        // Refund dust to recipient if any\n        if (dust > 0 && dustRecipient != address(0)) {\n            _refundDust(token, dustRecipient, dust, balance, depositAmount, isNative);\n        }\n\n        return data;\n    }\n\n    /**\n     * @notice Apply tick rounding to an amount\n     * @param amount The original amount\n     * @param tickSize The tick size (0 = no rounding)\n     * @return depositAmount The rounded amount to deposit\n     * @return dust The dust to refund\n     */\n    function _applyTickRounding(\n        uint256 amount,\n        uint256 tickSize\n    )\n        internal\n        pure\n        returns (uint256 depositAmount, uint256 dust)\n    {\n        if (tickSize == 0) {\n            return (amount, 0);\n        }\n\n        depositAmount = (amount / tickSize) * tickSize;\n        dust = amount - depositAmount;\n\n        // Ensure we have at least one tick worth\n        if (depositAmount == 0) {\n            revert AmountBelowMinimumTick(amount, tickSize);\n        }\n    }\n\n    /**\n     * @notice Refund dust to recipient\n     * @param token The token (or NATIVE_TOKEN)\n     * @param recipient The dust recipient\n     * @param dust The dust amount\n     * @param originalAmount The original amount before rounding\n     * @param depositedAmount The amount deposited after rounding\n     * @param isNative Whether this is native ETH\n     */\n    function _refundDust(\n        address token,\n        address recipient,\n        uint256 dust,\n        uint256 originalAmount,\n        uint256 depositedAmount,\n        bool isNative\n    )\n        internal\n    {\n        if (isNative) {\n            (bool refundSuccess,) = payable(recipient).call{ value: dust }(\"\");\n            if (!refundSuccess) revert DustRefundFailed();\n        } else {\n            IERC20(token).safeTransfer(recipient, dust);\n        }\n        emit DustRefunded(recipient, token, dust, originalAmount, depositedAmount);\n    }\n}\n"},"src/Utils/VaultConfigLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultConfigLib\n * @notice Library for packing vault configuration and function selectors into efficient storage\n * @dev Packs vault config flags and function selector into a single uint40 (5 bytes) for gas efficiency\n */\nlibrary VaultConfigLib {\n    // ============ Constants ============\n\n    /// @notice Bit flags for vault configuration\n    uint40 constant FLAG_IS_REGISTERED = 1 << 0; // bit 0: 0x01\n    uint40 constant FLAG_CONVERT_TO_18_DECIMALS = 1 << 1; // bit 1: 0x02\n    uint40 constant FLAG_ALLOWS_NATIVE = 1 << 2; // bit 2: 0x04\n\n    /// @notice Bitmasks for extracting packed data\n    uint40 constant SELECTOR_MASK = 0xFFFFFFFF00; // bits 8-39 for full bytes4 selector\n    uint40 constant FLAGS_MASK = 0x00000000FF; // bits 0-7 for flags\n\n    // ============ Structs ============\n\n    /**\n     * @notice Unpacked vault configuration struct\n     * @param isRegistered Whether the vault is registered for deposits\n     * @param convertTo18Decimals Whether to scale amounts to 18 decimals in calldata\n     * @param allowsNative Whether the vault accepts native ETH deposits\n     * @param allowedSelector The function selector that can be called on this vault\n     */\n    struct VaultConfig {\n        bool isRegistered;\n        bool convertTo18Decimals;\n        bool allowsNative;\n        bytes4 allowedSelector;\n    }\n\n    // ============ Packing Functions ============\n\n    /**\n     * @notice Pack a VaultConfig struct into a uint40\n     * @dev Bit layout:\n     *      - bits 0-7: flags (isRegistered, convertTo18Decimals, allowsNative)\n     *      - bits 8-39: function selector (32 bits)\n     * @param config The vault configuration to pack\n     * @return packed The packed configuration as uint40\n     */\n    function pack(VaultConfig memory config) internal pure returns (uint40 packed) {\n        // Pack flags into lower 8 bits\n        if (config.isRegistered) packed |= FLAG_IS_REGISTERED;\n        if (config.convertTo18Decimals) packed |= FLAG_CONVERT_TO_18_DECIMALS;\n        if (config.allowsNative) packed |= FLAG_ALLOWS_NATIVE;\n\n        // Pack function selector into upper 32 bits (shift left by 8 bits)\n        packed |= (uint40(uint32(config.allowedSelector)) << 8);\n    }\n\n    /**\n     * @notice Unpack a uint40 into a VaultConfig struct\n     * @param packed The packed configuration as uint40\n     * @return config The unpacked vault configuration\n     */\n    function unpack(uint40 packed) internal pure returns (VaultConfig memory config) {\n        config.isRegistered = (packed & FLAG_IS_REGISTERED) != 0;\n        config.convertTo18Decimals = (packed & FLAG_CONVERT_TO_18_DECIMALS) != 0;\n        config.allowsNative = (packed & FLAG_ALLOWS_NATIVE) != 0;\n        config.allowedSelector = bytes4(uint32((packed & SELECTOR_MASK) >> 8));\n    }\n\n    // ============ Utility Functions ============\n\n    /**\n     * @notice Extract just the function selector from packed config\n     * @param packed The packed configuration\n     * @return selector The function selector\n     */\n    function extractSelector(uint40 packed) internal pure returns (bytes4 selector) {\n        selector = bytes4(uint32((packed & SELECTOR_MASK) >> 8));\n    }\n\n    /**\n     * @notice Extract just the flags from packed config\n     * @param packed The packed configuration\n     * @return flags The configuration flags as uint8\n     */\n    function extractFlags(uint40 packed) internal pure returns (uint8 flags) {\n        flags = uint8(packed & FLAGS_MASK);\n    }\n\n    /**\n     * @notice Check if vault is registered\n     * @param packed The packed configuration\n     * @return True if vault is registered\n     */\n    function isRegistered(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_IS_REGISTERED) != 0;\n    }\n\n    /**\n     * @notice Check if vault requires 18 decimal conversion\n     * @param packed The packed configuration\n     * @return True if conversion to 18 decimals is required\n     */\n    function requiresConversion(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_CONVERT_TO_18_DECIMALS) != 0;\n    }\n\n    /**\n     * @notice Check if vault allows native ETH\n     * @param packed The packed configuration\n     * @return True if native ETH is allowed\n     */\n    function allowsNative(uint40 packed) internal pure returns (bool) {\n        return (packed & FLAG_ALLOWS_NATIVE) != 0;\n    }\n\n    /**\n     * @notice Update just the function selector in packed config\n     * @param packed The current packed configuration\n     * @param newSelector The new function selector\n     * @return updated The updated packed configuration\n     */\n    function updateSelector(uint40 packed, bytes4 newSelector) internal pure returns (uint40 updated) {\n        // Keep existing flags, replace selector\n        uint40 flags = packed & FLAGS_MASK;\n        uint40 packedSelector = (uint40(uint32(newSelector)) << 8);\n        updated = flags | packedSelector;\n    }\n}\n"},"src/Utils/VaultWrapperErrors.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultWrapperErrors\n * @notice Custom errors for VaultDepositWrapper contract\n * @dev Centralized error definitions for gas-efficient reverts\n */\ninterface VaultWrapperErrors {\n    /// @notice Thrown when calldata is too short to contain a valid placeholder\n    /// @dev Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)\n    /// @param reason Descriptive message explaining why the calldata is invalid\n    error InvalidCalldata(string reason);\n\n    /// @notice Thrown when trying to register the zero address as a vault\n    error InvalidVault();\n\n    /// @notice Thrown when vault ABI/method signature is empty\n    error EmptyMethodSignature();\n\n    /// @notice Thrown when trying to register a vault that is already registered\n    error VaultAlreadyRegistered();\n\n    /// @notice Thrown when trying to remove a vault that is not registered\n    error VaultNotRegistered();\n\n    /// @notice Thrown when deposit is called for an unregistered vault\n    error VaultNotRegisteredForDeposit();\n\n    /// @notice Thrown when no ETH is present in contract for native token deposit\n    error NoETHInContract();\n\n    /// @notice Thrown when ETH balance is below minimum amount out (slippage protection)\n    error InsufficientETHAmount();\n\n    /// @notice Thrown when token balance is below minimum amount out (slippage protection)\n    error InsufficientTokenAmount();\n\n    /// @notice Thrown when the vault deposit call fails\n    /// @param returnData The raw revert data returned by the failed vault call\n    error DepositFailed(bytes returnData);\n\n    /// @notice Thrown when attempting native ETH deposit to a vault that doesn't support it\n    error VaultDoesNotSupportNative();\n\n    /// @notice Thrown when trying to register a vault with an invalid (zero) function selector\n    error InvalidFunctionSelector();\n\n    /// @notice Thrown when trying to call a function selector that is not allowed for the vault\n    /// @param vault The vault address that was called\n    /// @param selector The function selector that was attempted\n    error SelectorNotAllowed(address vault, bytes4 selector);\n}\n"},"src/Utils/VaultWrapperEvents.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\n/**\n * @title VaultWrapperEvents\n * @notice Events emitted by VaultDepositWrapper contract\n * @dev Centralized event definitions for tracking contract state changes\n */\ninterface VaultWrapperEvents {\n    /// @notice Emitted when a new vault is registered by the owner\n    /// @param vault The address of the registered vault contract\n    /// @param methodSignature The deposit method signature for this vault (documentation only, not used for\n    /// replacement) @param convertTo18Decimals Whether amounts should be converted to 18 decimals for this vault (used\n    /// in deposit logic)\n    event VaultRegistered(address indexed vault, string methodSignature, bool convertTo18Decimals);\n\n    /// @notice Emitted when a vault is removed from the registry by the owner\n    /// @param vault The address of the vault that was removed\n    event VaultRemoved(address indexed vault);\n\n    /// @notice Emitted when this contract successfully deposits tokens into a vault\n    /// @param vault The vault contract that received the deposit\n    /// @param token The ERC20 token that was deposited\n    /// @param amount The actual amount of tokens deposited (in token's native decimals)\n    /// @param returnData The raw return data from the vault's deposit function call\n    event FunMediatedDeposit(address indexed vault, address indexed token, uint256 amount, bytes returnData);\n\n    /// @notice Emitted when a vault's allowed function selector is updated\n    /// @param vault The vault whose selector was updated\n    /// @param newSelector The new function selector\n    event SelectorUpdated(address indexed vault, bytes4 indexed newSelector);\n}\n"},"src/Utils/VaultDepositManager.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.27;\n\nimport { Ownable } from \"@openzeppelin/contracts/access/Ownable.sol\";\nimport { VaultWrapperErrors } from \"@fun-contracts/Utils/VaultWrapperErrors.sol\";\nimport { VaultWrapperEvents } from \"@fun-contracts/Utils/VaultWrapperEvents.sol\";\nimport { VaultConfigLib } from \"@fun-contracts/Utils/VaultConfigLib.sol\";\n\n/**\n * @title VaultDepositManager\n * @notice Admin functions for managing vault registrations\n * @dev Inherited by VaultDepositWrapper to separate admin logic from core deposit functionality\n *      All storage and constants must be defined here or in parent contracts for inheritance\n */\nabstract contract VaultDepositManager is Ownable, VaultWrapperErrors, VaultWrapperEvents {\n    using VaultConfigLib for uint40;\n    using VaultConfigLib for VaultConfigLib.VaultConfig;\n    // ============ Storage Layout ============\n    // Must be defined in inheritance order to match VaultDepositWrapper\n\n    /// @notice Mapping from vault address to packed configuration\n    /// @dev Each vault uses 5 bytes of storage (uint40) containing:\n    ///      - Configuration flags (isRegistered, convertTo18Decimals, allowsNative)\n    ///      - Allowed function selector (bytes4)\n    ///\n    ///      Gas savings vs separate mappings:\n    ///      - registerVault(): Single SSTORE for both config and selector\n    ///      - deposit(): Single SLOAD + library calls for validation\n    ///\n    ///      Security: Function selector whitelist prevents arbitrary function calls\n    mapping(address => uint40) public vaultConfigs;\n\n    // ============ Constructor ============\n\n    /// @notice Initialize with the specified owner\n    /// @param initialOwner The address to set as owner. If zero address, deployer becomes owner\n    constructor(address initialOwner) Ownable(initialOwner == address(0) ? msg.sender : initialOwner) {\n        // Owner is set directly in Ownable constructor - no additional transfer needed\n    }\n\n    // ============ Admin Functions ============\n\n    /**\n     * @notice Register a vault to enable deposits through this contract\n     * @dev Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().\n     *      The vault cannot be re-registered without first removing it.\n     *\n     *      Security: Only the specified function selector can be called on this vault\n     *      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)\n     *\n     * @param vault The address of the vault contract to register\n     * @param vaultABI The deposit method signature (e.g., \"deposit(uint256,address)\")\n     *        Emitted in VaultRegistered event for off-chain reference only\n     * @param allowedFunctionSelector The single function selector that can be called on this vault\n     *        Only this function can be invoked through the VaultWrapper for security\n     * @param convertTo18Decimals Whether to scale token amounts to 18 decimals before injecting into calldata\n     *        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)\n     *        - false: Amount is used as-is in token's native decimals\n     * @param allowsNative Whether this vault accepts native ETH deposits\n     *        - true: Vault can receive ETH via NATIVE_TOKEN parameter\n     *        - false: Vault only accepts ERC20 tokens\n     */\n    function registerVault(\n        address vault,\n        string memory vaultABI,\n        bytes4 allowedFunctionSelector,\n        bool convertTo18Decimals,\n        bool allowsNative\n    )\n        external\n        onlyOwner\n    {\n        if (vault == address(0)) revert InvalidVault();\n        if (bytes(vaultABI).length == 0) revert EmptyMethodSignature();\n        if (allowedFunctionSelector == bytes4(0)) revert InvalidFunctionSelector();\n        if (vaultConfigs[vault].isRegistered()) revert VaultAlreadyRegistered();\n\n        // Create configuration struct and pack it\n        VaultConfigLib.VaultConfig memory config = VaultConfigLib.VaultConfig({\n            isRegistered: true,\n            convertTo18Decimals: convertTo18Decimals,\n            allowsNative: allowsNative,\n            allowedSelector: allowedFunctionSelector\n        });\n\n        vaultConfigs[vault] = config.pack();\n\n        emit VaultRegistered(vault, vaultABI, convertTo18Decimals);\n    }\n\n    /**\n     * @notice Remove a vault from the registry, preventing future deposits\n     * @dev Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,\n     *      it only prevents new deposits through this contract.\n     *\n     * @param vault The address of the vault to remove from the registry\n     */\n    function removeVault(address vault) external onlyOwner {\n        if (!vaultConfigs[vault].isRegistered()) revert VaultNotRegistered();\n\n        delete vaultConfigs[vault];\n\n        emit VaultRemoved(vault);\n    }\n\n    /**\n     * @notice Update the allowed function selector for a registered vault\n     * @dev Only callable by owner. Changes the function that can be called on this vault.\n     * @param vault The registered vault address\n     * @param newSelector The new function selector to allow\n     */\n    function updateAllowedSelector(address vault, bytes4 newSelector) external onlyOwner {\n        if (!vaultConfigs[vault].isRegistered()) revert VaultNotRegistered();\n        if (newSelector == bytes4(0)) revert InvalidFunctionSelector();\n\n        vaultConfigs[vault] = vaultConfigs[vault].updateSelector(newSelector);\n\n        emit SelectorUpdated(vault, newSelector);\n    }\n\n    // ============ View Helpers ============\n\n    /**\n     * @notice Check if a vault is registered\n     * @param vault The vault address to check\n     * @return True if the vault is registered, false otherwise\n     */\n    function isVaultRegistered(address vault) external view returns (bool) {\n        return vaultConfigs[vault].isRegistered();\n    }\n\n    /**\n     * @notice Check if a vault requires 18-decimal conversion\n     * @param vault The vault address to check\n     * @return True if the vault requires amount scaling to 18 decimals, false otherwise\n     */\n    function vaultRequires18Decimals(address vault) external view returns (bool) {\n        return vaultConfigs[vault].requiresConversion();\n    }\n\n    /**\n     * @notice Check if a vault allows native ETH deposits\n     * @param vault The vault address to check\n     * @return True if the vault accepts native ETH, false if it only accepts ERC20 tokens\n     */\n    function vaultAllowsNative(address vault) external view returns (bool) {\n        return vaultConfigs[vault].allowsNative();\n    }\n\n    /**\n     * @notice Get the allowed function selector for a vault\n     * @param vault The vault address to check\n     * @return The function selector that can be called on this vault\n     */\n    function getAllowedSelector(address vault) external view returns (bytes4) {\n        return vaultConfigs[vault].extractSelector();\n    }\n\n    /**\n     * @notice Get the full vault configuration\n     * @param vault The vault address to check\n     * @return config The unpacked vault configuration\n     */\n    function getVaultConfig(address vault) external view returns (VaultConfigLib.VaultConfig memory config) {\n        return vaultConfigs[vault].unpack();\n    }\n\n    /**\n     * @notice Internal function to validate function selector before vault call\n     * @dev Extracts the function selector from calldata and checks if it matches the allowed selector\n     * @param vault The vault address being called\n     * @param callData The calldata being sent to the vault\n     */\n    function _validateSelector(address vault, bytes memory callData) internal view {\n        if (callData.length < 4) revert InvalidCalldata(\"Calldata too short for function selector\");\n\n        bytes4 calledSelector;\n        assembly {\n            calledSelector := mload(add(callData, 0x20))\n        }\n\n        bytes4 allowedSelector = vaultConfigs[vault].extractSelector();\n\n        if (calledSelector != allowedSelector) {\n            revert SelectorNotAllowed(vault, calledSelector);\n        }\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * The initial owner is set to the address provided by the deployer. This can\n * later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\n\n        if (!_callOptionalReturnBool(token, approvalCall)) {\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\n            _callOptionalReturn(token, approvalCall);\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            // bubble errors\n            if iszero(success) {\n                let ptr := mload(0x40)\n                returndatacopy(ptr, 0, returndatasize())\n                revert(ptr, returndatasize())\n            }\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     *\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\n     */\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\n        bool success;\n        uint256 returnSize;\n        uint256 returnValue;\n        assembly (\"memory-safe\") {\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\n            returnSize := returndatasize()\n            returnValue := mload(0)\n        }\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\n    }\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"}},"language":"Solidity","settings":{"debug":{"revertStrings":"debug"},"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":100,"enabled":true},"evmVersion":"cancun","remappings":["@CREATE3/=src/CREATE3/","@forge-std/=dependencies/forge-std-1.11.0/src/","@fun-contracts/=src/","@fun-test-contracts/=test/","@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.4.0/","@solmate/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/","CREATE3-1.0.0/=dependencies/CREATE3-1.0.0/","forge-std/=dependencies/forge-std-1.11.0/src/","@openzeppelin-contracts-5.4.0/=dependencies/@openzeppelin-contracts-5.4.0/","forge-std-1.11.0/=dependencies/forge-std-1.11.0/src/","solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/"]}},"stdJsonOutput":{"sources":{"src/Utils/Replacer.sol":{"id":10},"src/VaultDepositooorV2.sol":{"id":15},"src/Utils/VaultConfigLib.sol":{"id":11},"src/Utils/VaultWrapperErrors.sol":{"id":13},"src/Utils/VaultWrapperEvents.sol":{"id":14},"src/Utils/VaultDepositManager.sol":{"id":12},"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol":{"id":7},"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol":{"id":0},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol":{"id":3},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol":{"id":2},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol":{"id":4},"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol":{"id":1},"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol":{"id":8},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol":{"id":6},"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol":{"id":9},"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol":{"id":5}},"contracts":{"src/VaultDepositooorV2.sol":{"VaultDepositooorV2":{"abi":[{"type":"constructor","inputs":[{"name":"initialOwner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AmountBelowMinimumTick","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}]},{"name":"DepositFailed","type":"error","inputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}]},{"name":"DustRefundFailed","type":"error","inputs":[]},{"name":"EmptyMethodSignature","type":"error","inputs":[]},{"name":"InsufficientETHAmount","type":"error","inputs":[]},{"name":"InsufficientTokenAmount","type":"error","inputs":[]},{"name":"InvalidCalldata","type":"error","inputs":[{"name":"reason","type":"string","internalType":"string"}]},{"name":"InvalidDustRecipient","type":"error","inputs":[]},{"name":"InvalidFunctionSelector","type":"error","inputs":[]},{"name":"InvalidTickSize","type":"error","inputs":[]},{"name":"InvalidVault","type":"error","inputs":[]},{"name":"NoETHInContract","type":"error","inputs":[]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"SelectorNotAllowed","type":"error","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"selector","type":"bytes4","internalType":"bytes4"}]},{"name":"VaultAlreadyRegistered","type":"error","inputs":[]},{"name":"VaultDoesNotSupportNative","type":"error","inputs":[]},{"name":"VaultNotRegistered","type":"error","inputs":[]},{"name":"VaultNotRegisteredForDeposit","type":"error","inputs":[]},{"name":"DustRefunded","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"dust","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"originalAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"depositedAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FunMediatedDeposit","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"returnData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"SelectorUpdated","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"newSelector","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"VaultRegistered","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"},{"name":"methodSignature","type":"string","indexed":false,"internalType":"string"},{"name":"convertTo18Decimals","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"VaultRemoved","type":"event","inputs":[{"name":"vault","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"AMOUNT_PLACEHOLDER","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"AMOUNT_PLACEHOLDER_BYTES32","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"NATIVE_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"calculateTickRounding","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"roundedAmount","type":"uint256","internalType":"uint256"},{"name":"dust","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"deposit","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"vault","type":"address","internalType":"address"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"depositWithTick","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"vault","type":"address","internalType":"address"},{"name":"callData","type":"bytes","internalType":"bytes"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"},{"name":"dustRecipient","type":"address","internalType":"address"}],"outputs":[{"name":"returnData","type":"bytes","internalType":"bytes"}],"stateMutability":"nonpayable"},{"name":"getAllowedSelector","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"view"},{"name":"getMinimumDepositForTick","type":"function","inputs":[{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"minAmount","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"getVaultConfig","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"config","type":"tuple","components":[{"name":"isRegistered","type":"bool","internalType":"bool"},{"name":"convertTo18Decimals","type":"bool","internalType":"bool"},{"name":"allowsNative","type":"bool","internalType":"bool"},{"name":"allowedSelector","type":"bytes4","internalType":"bytes4"}],"internalType":"struct VaultConfigLib.VaultConfig"}],"stateMutability":"view"},{"name":"isVaultRegistered","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"registerVault","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"vaultABI","type":"string","internalType":"string"},{"name":"allowedFunctionSelector","type":"bytes4","internalType":"bytes4"},{"name":"convertTo18Decimals","type":"bool","internalType":"bool"},{"name":"allowsNative","type":"bool","internalType":"bool"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeVault","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"updateAllowedSelector","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"},{"name":"newSelector","type":"bytes4","internalType":"bytes4"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"validateAmountForTick","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"tickSize","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"isValid","type":"bool","internalType":"bool"},{"name":"roundedAmount","type":"uint256","internalType":"uint256"},{"name":"dust","type":"uint256","internalType":"uint256"}],"stateMutability":"pure"},{"name":"vaultAllowsNative","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"vaultConfigs","type":"function","inputs":[{"name":"","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint40","internalType":"uint40"}],"stateMutability":"view"},{"name":"vaultRequires18Decimals","type":"function","inputs":[{"name":"vault","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.27+commit.40a35a09\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tickSize\",\"type\":\"uint256\"}],\"name\":\"AmountBelowMinimumTick\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"DepositFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DustRefundFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"EmptyMethodSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientETHAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientTokenAmount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"string\",\"name\":\"reason\",\"type\":\"string\"}],\"name\":\"InvalidCalldata\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidDustRecipient\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidFunctionSelector\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTickSize\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidVault\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoETHInContract\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"SelectorNotAllowed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"VaultAlreadyRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"VaultDoesNotSupportNative\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"VaultNotRegistered\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"VaultNotRegisteredForDeposit\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"dust\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"originalAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"depositedAmount\",\"type\":\"uint256\"}],\"name\":\"DustRefunded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"name\":\"FunMediatedDeposit\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bytes4\",\"name\":\"newSelector\",\"type\":\"bytes4\"}],\"name\":\"SelectorUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"string\",\"name\":\"methodSignature\",\"type\":\"string\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"convertTo18Decimals\",\"type\":\"bool\"}],\"name\":\"VaultRegistered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"VaultRemoved\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"AMOUNT_PLACEHOLDER\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"AMOUNT_PLACEHOLDER_BYTES32\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"NATIVE_TOKEN\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tickSize\",\"type\":\"uint256\"}],\"name\":\"calculateTickRounding\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"roundedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"dust\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tickSize\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"dustRecipient\",\"type\":\"address\"}],\"name\":\"depositWithTick\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"returnData\",\"type\":\"bytes\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"getAllowedSelector\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tickSize\",\"type\":\"uint256\"}],\"name\":\"getMinimumDepositForTick\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmount\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"getVaultConfig\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"isRegistered\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"convertTo18Decimals\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"allowsNative\",\"type\":\"bool\"},{\"internalType\":\"bytes4\",\"name\":\"allowedSelector\",\"type\":\"bytes4\"}],\"internalType\":\"struct VaultConfigLib.VaultConfig\",\"name\":\"config\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"isVaultRegistered\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"vaultABI\",\"type\":\"string\"},{\"internalType\":\"bytes4\",\"name\":\"allowedFunctionSelector\",\"type\":\"bytes4\"},{\"internalType\":\"bool\",\"name\":\"convertTo18Decimals\",\"type\":\"bool\"},{\"internalType\":\"bool\",\"name\":\"allowsNative\",\"type\":\"bool\"}],\"name\":\"registerVault\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"removeVault\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"},{\"internalType\":\"bytes4\",\"name\":\"newSelector\",\"type\":\"bytes4\"}],\"name\":\"updateAllowedSelector\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"tickSize\",\"type\":\"uint256\"}],\"name\":\"validateAmountForTick\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"isValid\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"roundedAmount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"dust\",\"type\":\"uint256\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"vaultAllowsNative\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"vaultConfigs\",\"outputs\":[{\"internalType\":\"uint40\",\"name\":\"\",\"type\":\"uint40\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"vault\",\"type\":\"address\"}],\"name\":\"vaultRequires18Decimals\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"author\":\"dextracker\",\"details\":\"Tick sizes are passed per-call (not per-vault) because different assets on the same vault      may have different tick sizes. For example, Lighter uses:      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)      - USDC: tickSize = 1 (no rounding needed)      The depositWithTick() function:      - Rounds deposit amounts DOWN to the nearest tick size      - Refunds any dust (remainder) to a specified recipient      - Supports both ERC20 tokens and native ETH\",\"errors\":{\"DepositFailed(bytes)\":[{\"params\":{\"returnData\":\"The raw revert data returned by the failed vault call\"}}],\"InvalidCalldata(string)\":[{\"details\":\"Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)\",\"params\":{\"reason\":\"Descriptive message explaining why the calldata is invalid\"}}],\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}],\"SelectorNotAllowed(address,bytes4)\":[{\"params\":{\"selector\":\"The function selector that was attempted\",\"vault\":\"The vault address that was called\"}}]},\"events\":{\"DustRefunded(address,address,uint256,uint256,uint256)\":{\"params\":{\"depositedAmount\":\"The amount actually deposited after rounding\",\"dust\":\"The amount of dust refunded\",\"originalAmount\":\"The original amount before rounding\",\"recipient\":\"The address receiving the dust\",\"token\":\"The token address (or NATIVE_TOKEN for ETH)\"}},\"FunMediatedDeposit(address,address,uint256,bytes)\":{\"params\":{\"amount\":\"The actual amount of tokens deposited (in token's native decimals)\",\"returnData\":\"The raw return data from the vault's deposit function call\",\"token\":\"The ERC20 token that was deposited\",\"vault\":\"The vault contract that received the deposit\"}},\"SelectorUpdated(address,bytes4)\":{\"params\":{\"newSelector\":\"The new function selector\",\"vault\":\"The vault whose selector was updated\"}},\"VaultRegistered(address,string,bool)\":{\"params\":{\"convertTo18Decimals\":\"Whether amounts should be converted to 18 decimals for this vault (used in deposit logic)\",\"methodSignature\":\"The deposit method signature for this vault (documentation only, not used for\",\"vault\":\"The address of the registered vault contract\"}},\"VaultRemoved(address)\":{\"params\":{\"vault\":\"The address of the vault that was removed\"}}},\"kind\":\"dev\",\"methods\":{\"calculateTickRounding(uint256,uint256)\":{\"details\":\"Pure function for off-chain calculation and validation\",\"params\":{\"amount\":\"The input amount to round\",\"tickSize\":\"The tick size to round down to\"},\"returns\":{\"dust\":\"The remainder (amount - roundedAmount)\",\"roundedAmount\":\"The amount rounded down to nearest tick\"}},\"constructor\":{\"params\":{\"initialOwner\":\"Address to transfer ownership to, or address(0) to keep deployer as owner\"}},\"deposit(address,address,bytes,uint256)\":{\"details\":\"Standard deposit function without tick rounding - same as V1\",\"params\":{\"callData\":\"The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position\",\"minAmountOut\":\"Minimum token/ETH balance required for deposit (slippage/frontrunning protection)\",\"token\":\"The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH\",\"vault\":\"The registered vault contract to deposit into\"},\"returns\":{\"returnData\":\"The raw bytes returned from the vault's deposit function call\"}},\"depositWithTick(address,address,bytes,uint256,uint256,address)\":{\"details\":\"Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.      Why tickSize is per-call (not per-vault):      Different assets on the same vault may have different tick sizes.      Example: Lighter ETH tickSize=10^10, USDC tickSize=1      Example with tickSize = 10^10 (Lighter ETH):      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)      - Dust refunded: 123 wei\",\"params\":{\"callData\":\"The vault function calldata containing AMOUNT_PLACEHOLDER\",\"dustRecipient\":\"Address to receive any dust from rounding (must not be zero)\",\"minAmountOut\":\"Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)\",\"tickSize\":\"The tick size to round down to (must be > 0)\",\"token\":\"The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH\",\"vault\":\"The registered vault contract to deposit into\"},\"returns\":{\"returnData\":\"The raw bytes returned from the vault's deposit function call\"}},\"getAllowedSelector(address)\":{\"params\":{\"vault\":\"The vault address to check\"},\"returns\":{\"_0\":\"The function selector that can be called on this vault\"}},\"getMinimumDepositForTick(uint256)\":{\"details\":\"The minimum is exactly one tick\",\"params\":{\"tickSize\":\"The tick size\"},\"returns\":{\"minAmount\":\"The minimum valid deposit amount\"}},\"getVaultConfig(address)\":{\"params\":{\"vault\":\"The vault address to check\"},\"returns\":{\"config\":\"The unpacked vault configuration\"}},\"isVaultRegistered(address)\":{\"params\":{\"vault\":\"The vault address to check\"},\"returns\":{\"_0\":\"True if the vault is registered, false otherwise\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"registerVault(address,string,bytes4,bool,bool)\":{\"details\":\"Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().      The vault cannot be re-registered without first removing it.      Security: Only the specified function selector can be called on this vault      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)\",\"params\":{\"allowedFunctionSelector\":\"The single function selector that can be called on this vault        Only this function can be invoked through the VaultWrapper for security\",\"allowsNative\":\"Whether this vault accepts native ETH deposits        - true: Vault can receive ETH via NATIVE_TOKEN parameter        - false: Vault only accepts ERC20 tokens\",\"convertTo18Decimals\":\"Whether to scale token amounts to 18 decimals before injecting into calldata        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)        - false: Amount is used as-is in token's native decimals\",\"vault\":\"The address of the vault contract to register\",\"vaultABI\":\"The deposit method signature (e.g., \\\"deposit(uint256,address)\\\")        Emitted in VaultRegistered event for off-chain reference only\"}},\"removeVault(address)\":{\"details\":\"Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,      it only prevents new deposits through this contract.\",\"params\":{\"vault\":\"The address of the vault to remove from the registry\"}},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"updateAllowedSelector(address,bytes4)\":{\"details\":\"Only callable by owner. Changes the function that can be called on this vault.\",\"params\":{\"newSelector\":\"The new function selector to allow\",\"vault\":\"The registered vault address\"}},\"validateAmountForTick(uint256,uint256)\":{\"details\":\"Returns true if amount >= tickSize (at least one full tick)\",\"params\":{\"amount\":\"The amount to check\",\"tickSize\":\"The tick size requirement\"},\"returns\":{\"dust\":\"The amount that would be refunded as dust\",\"isValid\":\"True if amount is valid for the tick size\",\"roundedAmount\":\"The amount that would be deposited\"}},\"vaultAllowsNative(address)\":{\"params\":{\"vault\":\"The vault address to check\"},\"returns\":{\"_0\":\"True if the vault accepts native ETH, false if it only accepts ERC20 tokens\"}},\"vaultRequires18Decimals(address)\":{\"params\":{\"vault\":\"The vault address to check\"},\"returns\":{\"_0\":\"True if the vault requires amount scaling to 18 decimals, false otherwise\"}}},\"title\":\"VaultDepositooorV2\",\"version\":1},\"userdoc\":{\"errors\":{\"DepositFailed(bytes)\":[{\"notice\":\"Thrown when the vault deposit call fails\"}],\"EmptyMethodSignature()\":[{\"notice\":\"Thrown when vault ABI/method signature is empty\"}],\"InsufficientETHAmount()\":[{\"notice\":\"Thrown when ETH balance is below minimum amount out (slippage protection)\"}],\"InsufficientTokenAmount()\":[{\"notice\":\"Thrown when token balance is below minimum amount out (slippage protection)\"}],\"InvalidCalldata(string)\":[{\"notice\":\"Thrown when calldata is too short to contain a valid placeholder\"}],\"InvalidFunctionSelector()\":[{\"notice\":\"Thrown when trying to register a vault with an invalid (zero) function selector\"}],\"InvalidVault()\":[{\"notice\":\"Thrown when trying to register the zero address as a vault\"}],\"NoETHInContract()\":[{\"notice\":\"Thrown when no ETH is present in contract for native token deposit\"}],\"SelectorNotAllowed(address,bytes4)\":[{\"notice\":\"Thrown when trying to call a function selector that is not allowed for the vault\"}],\"VaultAlreadyRegistered()\":[{\"notice\":\"Thrown when trying to register a vault that is already registered\"}],\"VaultDoesNotSupportNative()\":[{\"notice\":\"Thrown when attempting native ETH deposit to a vault that doesn't support it\"}],\"VaultNotRegistered()\":[{\"notice\":\"Thrown when trying to remove a vault that is not registered\"}],\"VaultNotRegisteredForDeposit()\":[{\"notice\":\"Thrown when deposit is called for an unregistered vault\"}]},\"events\":{\"DustRefunded(address,address,uint256,uint256,uint256)\":{\"notice\":\"Emitted when dust is refunded to a recipient after tick rounding\"},\"FunMediatedDeposit(address,address,uint256,bytes)\":{\"notice\":\"Emitted when this contract successfully deposits tokens into a vault\"},\"SelectorUpdated(address,bytes4)\":{\"notice\":\"Emitted when a vault's allowed function selector is updated\"},\"VaultRegistered(address,string,bool)\":{\"notice\":\"Emitted when a new vault is registered by the owner\"},\"VaultRemoved(address)\":{\"notice\":\"Emitted when a vault is removed from the registry by the owner\"}},\"kind\":\"user\",\"methods\":{\"AMOUNT_PLACEHOLDER()\":{\"notice\":\"Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime\"},\"NATIVE_TOKEN()\":{\"notice\":\"Address used to represent native ETH (follows common convention)\"},\"calculateTickRounding(uint256,uint256)\":{\"notice\":\"Calculate the tick-rounded amount and dust for a given input\"},\"constructor\":{\"notice\":\"Initializes the contract and optionally transfers ownership\"},\"deposit(address,address,bytes,uint256)\":{\"notice\":\"Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault\"},\"depositWithTick(address,address,bytes,uint256,uint256,address)\":{\"notice\":\"Deposit with tick-size rounding for protocols requiring exact amount multiples\"},\"getAllowedSelector(address)\":{\"notice\":\"Get the allowed function selector for a vault\"},\"getMinimumDepositForTick(uint256)\":{\"notice\":\"Get the minimum deposit amount for a given tick size\"},\"getVaultConfig(address)\":{\"notice\":\"Get the full vault configuration\"},\"isVaultRegistered(address)\":{\"notice\":\"Check if a vault is registered\"},\"registerVault(address,string,bytes4,bool,bool)\":{\"notice\":\"Register a vault to enable deposits through this contract\"},\"removeVault(address)\":{\"notice\":\"Remove a vault from the registry, preventing future deposits\"},\"updateAllowedSelector(address,bytes4)\":{\"notice\":\"Update the allowed function selector for a registered vault\"},\"validateAmountForTick(uint256,uint256)\":{\"notice\":\"Check if an amount is valid for a given tick size\"},\"vaultAllowsNative(address)\":{\"notice\":\"Check if a vault allows native ETH deposits\"},\"vaultConfigs(address)\":{\"notice\":\"Mapping from vault address to packed configuration\"},\"vaultRequires18Decimals(address)\":{\"notice\":\"Check if a vault requires 18-decimal conversion\"}},\"notice\":\"Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter         that require deposit amounts to be exact multiples of a tick size.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/VaultDepositooorV2.sol\":\"VaultDepositooorV2\"},\"debug\":{\"revertStrings\":\"debug\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100},\"remappings\":[\":@CREATE3/=src/CREATE3/\",\":@forge-std/=dependencies/forge-std-1.11.0/src/\",\":@fun-contracts/=src/\",\":@fun-test-contracts/=test/\",\":@openzeppelin-contracts-5.4.0/=dependencies/@openzeppelin-contracts-5.4.0/\",\":@openzeppelin/contracts/=dependencies/@openzeppelin-contracts-5.4.0/\",\":@solmate/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/\",\":CREATE3-1.0.0/=dependencies/CREATE3-1.0.0/\",\":forge-std-1.11.0/=dependencies/forge-std-1.11.0/src/\",\":forge-std/=dependencies/forge-std-1.11.0/src/\",\":solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/=dependencies/solmate-89365b880c4f3c786bdd453d4b8e8fe410344a69/src/\"],\"viaIR\":true},\"sources\":{\"dependencies/@openzeppelin-contracts-5.4.0/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC1363.sol\":{\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100\",\"dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d\"]},\"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC165.sol\":{\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037\",\"dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ\"]},\"dependencies/@openzeppelin-contracts-5.4.0/interfaces/IERC20.sol\":{\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d\",\"dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF\"]},\"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303\",\"dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV\"]},\"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f95ee0bbd4dd3ac730d066ba3e785ded4565e890dbec2fa7d3b9fe3bad9d0d6e\",\"dweb:/ipfs/QmSLr6bHkPFWT7ntj34jmwfyskpwo97T9jZUrk5sz3sdtR\"]},\"dependencies/@openzeppelin-contracts-5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8150ceb4ac947e8a442b2a9c017e01e880b2be2dd958f1fa9bc405f4c5a86508\",\"dweb:/ipfs/QmbcBmFX66AY6Kbhnd5gx7zpkgqnUafo43XnmayAM7zVdB\"]},\"dependencies/@openzeppelin-contracts-5.4.0/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"dependencies/@openzeppelin-contracts-5.4.0/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"dependencies/@openzeppelin-contracts-5.4.0/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]},\"src/Utils/Replacer.sol\":{\"keccak256\":\"0x6a9a46ee21f2d5dc82d0de5f7a8383c6e10770a422566febbd424c9f190c0a8a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6afa8de9b6dbbdc28d20da59aaa903583f5e01d715f050e84b7372abbb4506ac\",\"dweb:/ipfs/QmPT8gRG9f3DbKVyTbBChqpBrgCpxnzPbzEvPbAFmiFh4H\"]},\"src/Utils/VaultConfigLib.sol\":{\"keccak256\":\"0xc02fcf314428103195b2c61b5d3703c8e9ee23969565190cdf1c3fa4973ed926\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://91a99fcef41d251c733820c54045394ee47449a6ffc2b24ce58cf0ab282a93e1\",\"dweb:/ipfs/QmfDYc3FySGTEJBiY6UeCX4gfA3Yru97dyUopM5KrXQnXy\"]},\"src/Utils/VaultDepositManager.sol\":{\"keccak256\":\"0x15078e0157b0bfe0d7ff7272209c42d08765d5a8ae4f92f724589f9102154b90\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53afb775be47b541389cffcf65021f08094c572870a18bc5a0942654e4f5d34a\",\"dweb:/ipfs/QmdYJDcbFfDTQSkGC7uKELX2XcQk1boqzmuK45RuyDKkHL\"]},\"src/Utils/VaultWrapperErrors.sol\":{\"keccak256\":\"0x554a4c5082591ba76cb4a977593a9ac01c760badb9e213f1088c638cf9614078\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d382c930426da297d2e6bc824305b5730dbb09575545f82bb4b7c24d0cda476c\",\"dweb:/ipfs/QmRwMHrVEePyGMLrt5ZQwn1eWEJc9PXfJRS8LG5GT3XEBV\"]},\"src/Utils/VaultWrapperEvents.sol\":{\"keccak256\":\"0x90d3e0391e3cfb5ab25f2d82f9ada85a1438a563ac185ed13c93746e197e4ebb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2a83a8c2e6d070b5d7177ee16916bf4c88c70791bc83e3e436d8f5b8dc26cd20\",\"dweb:/ipfs/QmRuPhyhEibsp3sqT9gnzEe2CG8tamjQ6hoC8B9yE86PN5\"]},\"src/VaultDepositooorV2.sol\":{\"keccak256\":\"0x633474cf97f316048c8786578e51c25be936686542c634fb2cfbf05495f611a5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://82bbf389f29dfd2d7f117de65f8221147c13bbfde571b796eb2029d4bf0845f1\",\"dweb:/ipfs/QmbqP8FsKmsBxHK3bLfdtmcBnVCZC2dy6eM6LnNk1rUXWk\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"InvalidVault()":[{"notice":"Thrown when trying to register the zero address as a vault"}],"NoETHInContract()":[{"notice":"Thrown when no ETH is present in contract for native token deposit"}],"DepositFailed(bytes)":[{"notice":"Thrown when the vault deposit call fails"}],"VaultNotRegistered()":[{"notice":"Thrown when trying to remove a vault that is not registered"}],"EmptyMethodSignature()":[{"notice":"Thrown when vault ABI/method signature is empty"}],"InsufficientETHAmount()":[{"notice":"Thrown when ETH balance is below minimum amount out (slippage protection)"}],"InvalidCalldata(string)":[{"notice":"Thrown when calldata is too short to contain a valid placeholder"}],"VaultAlreadyRegistered()":[{"notice":"Thrown when trying to register a vault that is already registered"}],"InsufficientTokenAmount()":[{"notice":"Thrown when token balance is below minimum amount out (slippage protection)"}],"InvalidFunctionSelector()":[{"notice":"Thrown when trying to register a vault with an invalid (zero) function selector"}],"VaultDoesNotSupportNative()":[{"notice":"Thrown when attempting native ETH deposit to a vault that doesn't support it"}],"VaultNotRegisteredForDeposit()":[{"notice":"Thrown when deposit is called for an unregistered vault"}],"SelectorNotAllowed(address,bytes4)":[{"notice":"Thrown when trying to call a function selector that is not allowed for the vault"}]},"events":{"VaultRemoved(address)":{"notice":"Emitted when a vault is removed from the registry by the owner"},"SelectorUpdated(address,bytes4)":{"notice":"Emitted when a vault's allowed function selector is updated"},"VaultRegistered(address,string,bool)":{"notice":"Emitted when a new vault is registered by the owner"},"FunMediatedDeposit(address,address,uint256,bytes)":{"notice":"Emitted when this contract successfully deposits tokens into a vault"},"DustRefunded(address,address,uint256,uint256,uint256)":{"notice":"Emitted when dust is refunded to a recipient after tick rounding"}},"notice":"Extension of VaultDepositooor with tick-size-aware deposits for protocols like Lighter         that require deposit amounts to be exact multiples of a tick size.","methods":{"constructor":{"notice":"Initializes the contract and optionally transfers ownership"},"NATIVE_TOKEN()":{"notice":"Address used to represent native ETH (follows common convention)"},"AMOUNT_PLACEHOLDER()":{"notice":"Special placeholder value used in calldata that gets replaced with the actual deposit amount at runtime"},"removeVault(address)":{"notice":"Remove a vault from the registry, preventing future deposits"},"vaultConfigs(address)":{"notice":"Mapping from vault address to packed configuration"},"getVaultConfig(address)":{"notice":"Get the full vault configuration"},"isVaultRegistered(address)":{"notice":"Check if a vault is registered"},"vaultAllowsNative(address)":{"notice":"Check if a vault allows native ETH deposits"},"getAllowedSelector(address)":{"notice":"Get the allowed function selector for a vault"},"vaultRequires18Decimals(address)":{"notice":"Check if a vault requires 18-decimal conversion"},"getMinimumDepositForTick(uint256)":{"notice":"Get the minimum deposit amount for a given tick size"},"updateAllowedSelector(address,bytes4)":{"notice":"Update the allowed function selector for a registered vault"},"calculateTickRounding(uint256,uint256)":{"notice":"Calculate the tick-rounded amount and dust for a given input"},"deposit(address,address,bytes,uint256)":{"notice":"Deposit the caller's entire token balance (or contract's ETH balance) into a registered vault"},"validateAmountForTick(uint256,uint256)":{"notice":"Check if an amount is valid for a given tick size"},"registerVault(address,string,bytes4,bool,bool)":{"notice":"Register a vault to enable deposits through this contract"},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"notice":"Deposit with tick-size rounding for protocols requiring exact amount multiples"}},"version":1},"devdoc":{"kind":"dev","title":"VaultDepositooorV2","author":"dextracker","errors":{"DepositFailed(bytes)":[{"params":{"returnData":"The raw revert data returned by the failed vault call"}}],"InvalidCalldata(string)":[{"params":{"reason":"Descriptive message explaining why the calldata is invalid"},"details":"Calldata must be at least 36 bytes (4-byte selector + 32-byte parameter)"}],"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"SelectorNotAllowed(address,bytes4)":[{"params":{"vault":"The vault address that was called","selector":"The function selector that was attempted"}}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"events":{"VaultRemoved(address)":{"params":{"vault":"The address of the vault that was removed"}},"SelectorUpdated(address,bytes4)":{"params":{"vault":"The vault whose selector was updated","newSelector":"The new function selector"}},"VaultRegistered(address,string,bool)":{"params":{"vault":"The address of the registered vault contract","methodSignature":"The deposit method signature for this vault (documentation only, not used for","convertTo18Decimals":"Whether amounts should be converted to 18 decimals for this vault (used in deposit logic)"}},"FunMediatedDeposit(address,address,uint256,bytes)":{"params":{"token":"The ERC20 token that was deposited","vault":"The vault contract that received the deposit","amount":"The actual amount of tokens deposited (in token's native decimals)","returnData":"The raw return data from the vault's deposit function call"}},"DustRefunded(address,address,uint256,uint256,uint256)":{"params":{"dust":"The amount of dust refunded","token":"The token address (or NATIVE_TOKEN for ETH)","recipient":"The address receiving the dust","originalAmount":"The original amount before rounding","depositedAmount":"The amount actually deposited after rounding"}}},"details":"Tick sizes are passed per-call (not per-vault) because different assets on the same vault      may have different tick sizes. For example, Lighter uses:      - ETH: tickSize = 10^10 (amounts must be multiples of 10 gwei)      - USDC: tickSize = 1 (no rounding needed)      The depositWithTick() function:      - Rounds deposit amounts DOWN to the nearest tick size      - Refunds any dust (remainder) to a specified recipient      - Supports both ERC20 tokens and native ETH","methods":{"owner()":{"details":"Returns the address of the current owner."},"constructor":{"params":{"initialOwner":"Address to transfer ownership to, or address(0) to keep deployer as owner"}},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"removeVault(address)":{"params":{"vault":"The address of the vault to remove from the registry"},"details":"Only callable by owner (Safe multisig). This does not affect any existing deposits in the vault,      it only prevents new deposits through this contract."},"getVaultConfig(address)":{"params":{"vault":"The vault address to check"},"returns":{"config":"The unpacked vault configuration"}},"isVaultRegistered(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault is registered, false otherwise"}},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"vaultAllowsNative(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault accepts native ETH, false if it only accepts ERC20 tokens"}},"getAllowedSelector(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"The function selector that can be called on this vault"}},"vaultRequires18Decimals(address)":{"params":{"vault":"The vault address to check"},"returns":{"_0":"True if the vault requires amount scaling to 18 decimals, false otherwise"}},"getMinimumDepositForTick(uint256)":{"params":{"tickSize":"The tick size"},"details":"The minimum is exactly one tick","returns":{"minAmount":"The minimum valid deposit amount"}},"updateAllowedSelector(address,bytes4)":{"params":{"vault":"The registered vault address","newSelector":"The new function selector to allow"},"details":"Only callable by owner. Changes the function that can be called on this vault."},"calculateTickRounding(uint256,uint256)":{"params":{"amount":"The input amount to round","tickSize":"The tick size to round down to"},"details":"Pure function for off-chain calculation and validation","returns":{"dust":"The remainder (amount - roundedAmount)","roundedAmount":"The amount rounded down to nearest tick"}},"deposit(address,address,bytes,uint256)":{"params":{"token":"The token to deposit - either ERC20 address or NATIVE_TOKEN (0xEeee...EEeE) for ETH","vault":"The registered vault contract to deposit into","callData":"The vault function calldata containing AMOUNT_PLACEHOLDER at the amount parameter position","minAmountOut":"Minimum token/ETH balance required for deposit (slippage/frontrunning protection)"},"details":"Standard deposit function without tick rounding - same as V1","returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}},"validateAmountForTick(uint256,uint256)":{"params":{"amount":"The amount to check","tickSize":"The tick size requirement"},"details":"Returns true if amount >= tickSize (at least one full tick)","returns":{"dust":"The amount that would be refunded as dust","isValid":"True if amount is valid for the tick size","roundedAmount":"The amount that would be deposited"}},"registerVault(address,string,bytes4,bool,bool)":{"params":{"vault":"The address of the vault contract to register","vaultABI":"The deposit method signature (e.g., \"deposit(uint256,address)\")        Emitted in VaultRegistered event for off-chain reference only","allowsNative":"Whether this vault accepts native ETH deposits        - true: Vault can receive ETH via NATIVE_TOKEN parameter        - false: Vault only accepts ERC20 tokens","convertTo18Decimals":"Whether to scale token amounts to 18 decimals before injecting into calldata        - true: Amount is multiplied by 10^(18-tokenDecimals) before replacement (for USDC: 6 decimals → 18)        - false: Amount is used as-is in token's native decimals","allowedFunctionSelector":"The single function selector that can be called on this vault        Only this function can be invoked through the VaultWrapper for security"},"details":"Only callable by owner (Safe multisig). Once registered, users can deposit into this vault via deposit().      The vault cannot be re-registered without first removing it.      Security: Only the specified function selector can be called on this vault      Gas optimization: Configuration and selector packed into single uint40 (5 bytes)"},"depositWithTick(address,address,bytes,uint256,uint256,address)":{"params":{"token":"The token to deposit - either ERC20 address or NATIVE_TOKEN for ETH","vault":"The registered vault contract to deposit into","callData":"The vault function calldata containing AMOUNT_PLACEHOLDER","tickSize":"The tick size to round down to (must be > 0)","minAmountOut":"Minimum amount AFTER tick rounding (reverts if rounded amount < minAmountOut)","dustRecipient":"Address to receive any dust from rounding (must not be zero)"},"details":"Rounds the deposit amount DOWN to the nearest tick size and refunds any dust to dustRecipient.      Why tickSize is per-call (not per-vault):      Different assets on the same vault may have different tick sizes.      Example: Lighter ETH tickSize=10^10, USDC tickSize=1      Example with tickSize = 10^10 (Lighter ETH):      - Input: 1000000000000000123 wei (1.000000000000000123 ETH)      - Deposited: 1000000000000000000 wei (1.0 ETH, rounded to tick)      - Dust refunded: 123 wei","returns":{"returnData":"The raw bytes returned from the vault's deposit function call"}}},"version":1},"storageLayout":{"types":{"t_uint40":{"label":"uint40","encoding":"inplace","numberOfBytes":"5"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_uint40)":{"key":"t_address","label":"mapping(address => uint40)","value":"t_uint40","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"},{"slot":"1","type":"t_mapping(t_address,t_uint40)","astId":1290,"label":"vaultConfigs","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"},{"slot":"2","type":"t_uint256","astId":846,"label":"_status","offset":0,"contract":"src/VaultDepositooorV2.sol:VaultDepositooorV2"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"1304:12178:15:-:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;1850:10:12;;1821:54;-1:-1:-1;;;;;1304:12178:15;1273:26:0;;1269:95;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;3052:40:0;;-1:-1:-1;3052:40:0;1857:1:8;2061:21;1857:1;1304:12178:15;;;;;;;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;1304:12178:15;;-1:-1:-1;1322:31:0;1821:54:12;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"60806040526004361015610015575b36610f5c57005b5f3560e01c8063105a88e31461015057806326604a431461014b5780632f9182cc1461014657806331f7d964146101415780633d18b2af1461013c57806342a6f7a514610137578063476b6acf146101325780634bfc50141461012d5780634cd10b8e14610128578063715018a6146101235780637f4c4847146100f65780638da5cb5b1461011e578063b139012d14610119578063cd86798514610114578063ceb68c231461010f578063d28c38041461010a578063de1eb9a314610105578063eb667c6c14610100578063f2fde38b146100fb5763fd7070460361000e575b610902565b610ed7565b610eaa565b610dbc565b610d86565b610d07565b61099b565b610948565b610921565b6108ab565b6107fd565b6106cf565b610692565b610560565b610521565b6104f3565b61046d565b6102d2565b61028b565b60405162461bcd60e51b815260206004820152602260248201527f45746865722073656e7420746f206e6f6e2d70617961626c652066756e63746960448201526137b760f11b6064820152608490fd5b60405162461bcd60e51b815260206004820152602260248201527f414249206465636f64696e673a207475706c65206461746120746f6f2073686f6044820152611c9d60f21b6064820152608490fd5b60405162461bcd60e51b815260206004820152602260248201527f414249206465636f64696e673a20696e76616c6964207475706c65206f666673604482015261195d60f21b6064820152608490fd5b600435906001600160a01b038216820361025b57565b5f80fd5b602435906001600160a01b038216820361025b57565b60a435906001600160a01b038216820361025b57565b346102cd5760203660031901126102c8576001600160a01b036102ac610245565b165f5260016020526020600160405f2054161515604051908152f35b6101a5565b610155565b346102cd5760203660031901126102c857600435806102f95750602060015b604051908152f35b6020906102f1565b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a1c9c985e481bd9999cd95d60aa1b6064820152608490fd5b634e487b7160e01b5f52604160045260245ffd5b90601f801991011681019081106001600160401b0382111761037c57604052565b610347565b6040519061039060808361035b565b565b6001600160401b03811161037c57601f01601f191660200190565b9291926103b982610392565b916103c7604051938461035b565b8294818452818301116103e3578281602093845f960137010152565b60405162461bcd60e51b815260206004820152602760248201527f414249206465636f64696e673a20696e76616c69642062797465206172726179604482015266040d8cadccee8d60cb1b6064820152608490fd5b602435906001600160e01b03198216820361025b57565b60643590811515820361025b57565b60843590811515820361025b57565b346102cd5760a03660031901126102c857610486610245565b6024356001600160401b0381116104ee57366023820112156104e9576104b69036906024816004013591016103ad565b60443591906001600160e01b03198316830361025b576104e7926104d861044f565b916104e161045e565b93610fb3565b005b610301565b6101f5565b346102cd575f3660031901126102c857602060405173eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee8152f35b346102cd5760203660031901126102c8576001600160a01b03610542610245565b165f526001602052602064ffffffffff60405f205416604051908152f35b346102cd5760403660031901126102c857610579610245565b610581610438565b6105896111bc565b6001600160a01b0382165f818152600160205260409020549091906105c0906105bc9064ffffffffff165b600116151590565b1590565b610683576001600160e01b031981169283156106745761063761061c61064e936106086105fd8560018060a01b03165f52600160205260405f2090565b5464ffffffffff1690565b60ff1660d89190911c64ffffffff00161790565b6001600160a01b039092165f90815260016020526040902090565b9064ffffffffff1664ffffffffff19825416179055565b7fd2f6827debfb2832d419a5f1fcc2bf414c1e1df8fdd7a232336079a86d3da1815f80a3005b6342868c9b60e01b5f5260045ffd5b63775a7b0960e11b5f5260045ffd5b346102cd5760203660031901126102c8576001600160a01b036106b3610245565b165f5260016020526020600260405f2054161515604051908152f35b346102cd5760203660031901126102c8576001600160a01b036106f0610245565b165f5260016020526020600460405f2054161515604051908152f35b9181601f840112156104e9578235916001600160401b03831161077f576020838186019501011161073957565b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a727261792073747269646560a81b6064820152608490fd5b60405162461bcd60e51b815260206004820152602b60248201525f516020611ac95f395f51905f5260448201526a0e4e4c2f240d8cadccee8d60ab1b6064820152608490fd5b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b9060206107fa9281815201906107c5565b90565b346102cd5760c03660031901126102c857610816610245565b61081e61025f565b906044356001600160401b0381116104ee5761083e90369060040161070c565b6064356084359161084d610275565b9361085661122f565b831561089c576001600160a01b0385161561088d576108899661087896611327565b6001600255604051918291826107e9565b0390f35b63a355f88960e01b5f5260045ffd5b63747a60fb60e01b5f5260045ffd5b346102cd575f3660031901126102c8576108c36111bc565b5f80546001600160a01b0319811682556001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a3005b346102cd575f3660031901126102c85760206040516321524110198152f35b346102cd575f3660031901126102c8575f546040516001600160a01b039091168152602090f35b346102cd5760203660031901126102c8576001600160a01b03610969610245565b165f9081526001602090815260409091205460d81b6001600160e01b0319166040516001600160e01b03199091168152f35b346102cd5760803660031901126102c8576109b4610245565b6109bc61025f565b906044356001600160401b0381116104ee576109dc90369060040161070c565b9190606435926109ea61122f565b6001600160a01b0385165f908152600160205260409020610a0a906105fd565b6001811615610cf8576001600160a01b0384169473eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee8614938415610c4f576004831615610c405747928315610c3157610a575f856115c5565b959095938610610c22575b859187159081610c15575b50610b6b575b5f9291610a96918493610a918d610a8b3685856103ad565b906116e9565b6117d0565b868214610b5257602081519101868b5af195610ab06112e1565b965b15610b3357604051610889986001600160a01b0316907f76511bb8950b82fe2ee5f747e5a7929769055ce5ade161da73b869147b1f5e3f9080610af68b8983611310565b0390a380151580610b2c575b610b18575b6001600255604051808888826107e9565b5f610b22956118a6565b5f80808080610b07565b505f610b02565b60405163f8e68f2360e01b815280610b4e89600483016107e9565b0390fd5b602081519101828b5af195610b656112e1565b96610ab2565b883b15610c105760405163313ce56760e01b8152916020836004818d5afa918215610c0b575f9460ff610a969487968791610bdc575b501660128110610bb8575b50945091509150610a73565b610bd5919350610bca610bcf9161110e565b6112d3565b896110f6565b915f610bac565b610bfe915060203d602011610c04575b610bf6818361035b565b8101906112ba565b5f610ba1565b503d610bec565b6112af565b61124d565b600216151590505f610a6d565b633b38932f60e11b5f5260045ffd5b63565dfaef60e11b5f5260045ffd5b637ca2885760e01b5f5260045ffd5b86939291933b15610c10576040516370a0823160e01b8152336004820152916020836024818b5afa928315610c0b575f93610cc7575b508293610c925f856115c5565b949080978110610cb857610cac610cb392308d339061160d565b8b8b611664565b610a62565b631762402160e11b5f5260045ffd5b610cea91935060203d602011610cf1575b610ce2818361035b565b8101906112a0565b915f610c85565b503d610cd8565b63077b4faf60e01b5f5260045ffd5b346102cd5760203660031901126102c857610d20610245565b610d286111bc565b6001600160a01b03165f81815260016020819052604090912054161561068357805f52600160205260405f2064ffffffffff1981541690557fe71f3a50e5ad81964f352c411f1d45e35438ecd1acecef59ac81d9fbbf6cbc0a5f80a2005b346102cd5760403660031901126102c8576060610da760243560043561112b565b90604051921515835260208301526040820152f35b346102cd5760203660031901126102c857610dd5610245565b610ddd61115f565b506001600160a01b03165f9081526001602052604090205461088990610e69610e58610e48610e3f64ffffffff00610e1361115f565b600187161515815260028716151560208201526004871615156040820152951660081c63ffffffff1690565b63ffffffff1690565b60e01b6001600160e01b03191690565b6001600160e01b0319166060830152565b60405191829182919091606060808201938051151583526020810151151560208401526040810151151560408401528163ffffffff60e01b91015116910152565b346102cd5760403660031901126102c8576040610ecb602435600435611193565b82519182526020820152f35b346102cd5760203660031901126102c857610ef0610245565b610ef86111bc565b6001600160a01b03168015610f49575f80546001600160a01b03198116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a3005b631e4fbdf760e01b5f525f60045260245ffd5b60405162461bcd60e51b815260206004820152602960248201527f556e6b6e6f776e207369676e617475726520616e64206e6f2066616c6c6261636044820152681ac81919599a5b995960ba1b6064820152608490fd5b939291610fbe6111bc565b6001600160a01b03851694851561109557825115611086576001600160e01b0319821615610674576001600160a01b0381165f90815260016020526040902061100a906105b4906105fd565b6110775761063761061c7f55e854e53b29a09bfbe28c9e867d99a35dbcc693f17da80c10b4e4607d747a3a9661105e61106395610e58611048610381565b60018152938a1515602086015215156040850152565b6111e2565b611072604051928392836110a4565b0390a2565b6324ec133760e11b5f5260045ffd5b630364bbe960e61b5f5260045ffd5b630681d31960e51b5f5260045ffd5b906110bc6020919493946040845260408401906107c5565b931515910152565b634e487b7160e01b5f52601160045260245ffd5b81156110e2570490565b634e487b7160e01b5f52601260045260245ffd5b8181029291811591840414171561110957565b6110c4565b601203906012821161110957565b601f1981019190821161110957565b908015611156578061114061114592846110d8565b6110f6565b908181039081116111095781151592565b50801515915f90565b60405190608082018281106001600160401b0382111761037c576040525f6060838281528260208201528260408201520152565b919080156111b757806111406111a992856110d8565b918281039081116111095790565b505f90565b5f546001600160a01b031633036111cf57565b63118cdaa760e01b5f523360045260245ffd5b5f908051611226575b602081015161121c575b6040810151611211575b6060015160d81c64ffffffff00161790565b6004909117906111ff565b90600217906111f5565b600191506111eb565b600280541461123e5760028055565b633ee5aeb560e01b5f5260045ffd5b60405162461bcd60e51b815260206004820152602560248201527f54617267657420636f6e747261637420646f6573206e6f7420636f6e7461696e60448201526420636f646560d81b6064820152608490fd5b908160209103126102c8575190565b6040513d5f823e3d90fd5b908160209103126102c8575160ff8116810361025b5790565b604d811161110957600a0a90565b3d1561130b573d906112f282610392565b91611300604051938461035b565b82523d5f602084013e565b606090565b6040906107fa9392815281602082015201906107c5565b94919390956113496105fd8860018060a01b03165f52600160205260405f2090565b946001861615610cf8576001600160a01b03871673eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee811496909190871561153e576004811615610c405747958615610c315761139990876115c5565b979097958810610c22575b8a88928a159081611531575b5061149f575b916113cd915f94610a918695610a8b3685856103ad565b88821461148657602081519101888c5af1976113e76112e1565b985b1561146b576040516001600160a01b03909116907f76511bb8950b82fe2ee5f747e5a7929769055ce5ade161da73b869147b1f5e3f908061142b8c8a83611310565b0390a381151580611459575b611445575b50505050505090565b61144e956118a6565b5f808080808061143c565b506001600160a01b0381161515611437565b60405163f8e68f2360e01b815280610b4e8b600483016107e9565b602081519101828c5af1976114996112e1565b986113e9565b5090833b15610c105760405163313ce56760e01b815290602082600481885afa928315610c0b575f948d60ff87966113cd968891611512575b5016601281106114f0575b50929450945091506113b6565b610a91919450611505610bca61150b9261110e565b8d6110f6565b93906114e3565b61152b915060203d602011610c0457610bf6818361035b565b5f6114d8565b600216151590505f6113b0565b829694963b15610c10576040516370a0823160e01b815233600482015294602086602481875afa958615610c0b575f966115a4575b5061157f8697876115c5565b969080998110610cb85761159861159f9230338961160d565b8c86611664565b6113a4565b6115be91965060203d602011610cf157610ce2818361035b565b945f611573565b90918215611606576115db8361114081856110d8565b92838303838111611109579284156115f1575050565b63d9e3812360e01b5f5260045260245260445ffd5b9150905f90565b6040516323b872dd60e01b60208201526001600160a01b0392831660248201529290911660448301526064808301939093529181526103909161165160848361035b565b6119a5565b906020820180921161110957565b916001600160a01b0383169190823b15610c1057604051636eb1769f60e11b81523060048201526001600160a01b038316602482015292602090849060449082905afa928315610c0b575f936116c8575b50820180921161110957610390926119fd565b6116e291935060203d602011610cf157610ce2818361035b565b915f6116b5565b90600481511061177957602001519061173d61173064ffffffffff61171e8460018060a01b03165f52600160205260405f2090565b541660d81b6001600160e01b03191690565b6001600160e01b03191690565b6001600160e01b0319831603611751575050565b6375e81e2960e11b5f526001600160a01b03166004526001600160e01b03191660245260445ffd5b6040516316a434ff60e21b815260206004820152602860248201527f43616c6c6461746120746f6f2073686f727420666f722066756e6374696f6e2060448201526739b2b632b1ba37b960c11b6064820152608490fd5b6117db9136916103ad565b602481511061182c57906004915b6117f3815161111c565b831161182657602083820101926321524110198451146118205761181991929350611656565b91906117e9565b50915290565b91505090565b6040516316a434ff60e21b815260206004820152604560248201527f43616c6c206461746120697320746f6f2073686f727420746f20696e636c756460448201527f652073656c6563746f7220616e64206174206c65617374206f6e65207061726160648201526436b2ba32b960d91b608482015260a490fd5b9290949391935f1461192d575f808080876001600160a01b038a165af16118cb6112e1565b501561191e577feb89cc1a0c6b99cb87f8608d2089862fc42b7f8cb003e2401ea646032177b28c925b604080519586526020860192909252908401919091526001600160a01b03908116931691606090a3565b63132fd5e360e11b5f5260045ffd5b60405163a9059cbb60e01b60208201526001600160a01b0386166024820152604481018590527feb89cc1a0c6b99cb87f8608d2089862fc42b7f8cb003e2401ea646032177b28c93906119a09061199181606481015b03601f19810183528261035b565b6001600160a01b0383166119a5565b6118f4565b905f602091828151910182855af1156112af575f513d6119f457506001600160a01b0381163b155b6119d45750565b635274afe760e01b5f9081526001600160a01b0391909116600452602490fd5b600114156119cd565b60405163095ea7b360e01b60208083019182526001600160a01b0385166024840152604480840196909652948252929390925f90611a3c60648661035b565b84519082855af15f51903d81611a9c575b501590505b611a5b57505050565b60405163095ea7b360e01b60208201526001600160a01b0390931660248401525f60448401526103909261165190611a968160648101611983565b826119a5565b15159050611abc5750611a526001600160a01b0382163b15155b5f611a4d565b6001611a529114611ab656fe414249206465636f64696e673a20696e76616c69642063616c6c646174612061a264697066735822122076617063a96bad71bfcd134d654760133c1ba640afac43490299d5245590b95e64736f6c634300081b0033","sourceMap":"1304:12178:15:-:0;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;5927:12:12;1304:12178:15;;;5927:12:12;1304:12178:15;-1:-1:-1;1304:12178:15;;3770:27:11;3769:34;;1304:12178:15;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;5252:13;;;:28;1304:12178;5268:1;5252:28;1304:12178;;;;;;5252:28;1304:12178;5252:28;;;1304:12178;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;:::o;:::-;;:::i;:::-;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;;;;;1304:12178:15;;;;;;-1:-1:-1;;1304:12178:15;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;:::o;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;3416:962:12;1304:12178:15;;;:::i;:::-;;;;:::i;:::-;3416:962:12;;:::i;:::-;1304:12178:15;;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;2003:42;1304:12178;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;1531:46:12;1304:12178:15;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;5339:35:12;;5340:34;;1304:12178:15;;5340:19:12;453:6:11;3770:27;3769:34;;3686:124;;5340:34:12;5339:35;;1304:12178:15;5339:35:12;5335:68;;-1:-1:-1;;;;;;1304:12178:15;;;5417:24:12;;5413:62;;5486:19;5508:47;5486:69;5508:19;;;;1304:12178:15;;;;;;;;5340:12:12;1304:12178:15;;;;;;;5508:19:12;1304:12178:15;;;;;5508:19:12;787:12:11;4846:19;1304:12178:15;;;;;;;4953:22:11;;4674:308;5508:47:12;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;5486:19:12;1304:12178:15;;;;;;;;;;;;5486:69:12;5571:35;-1:-1:-1;5571:35:12;;1304:12178:15;5413:62:12;5450:25;;;-1:-1:-1;5450:25:12;1304:12178:15;-1:-1:-1;5450:25:12;5335:68;5383:20;;;-1:-1:-1;5383:20:12;1304:12178:15;-1:-1:-1;5383:20:12;1304:12178:15;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;6283:12:12;1304:12178:15;;;526:6:11;1304:12178:15;-1:-1:-1;1304:12178:15;;4090:36:11;4089:43;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;6637:12:12;1304:12178:15;;;590:6:11;1304:12178:15;-1:-1:-1;1304:12178:15;;4384:27:11;4383:34;;1304:12178:15;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1304:12178:15;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;-1:-1:-1;;1304:12178:15;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;2466:103:8;;;:::i;:::-;7914:13:15;;7910:43;;-1:-1:-1;;;;;1304:12178:15;;7967:27;7963:62;;1304:12178;8043:71;;;;:::i;:::-;1857:1:8;3068:21;1899:1;1304:12178:15;;;;;;;:::i;:::-;;;;7963:62;8003:22;;;-1:-1:-1;8003:22:15;1304:12178;-1:-1:-1;8003:22:15;7910:43;7936:17;;;-1:-1:-1;7936:17:15;1304:12178;-1:-1:-1;7936:17:15;1304:12178;;;;;;-1:-1:-1;;1304:12178:15;;;;1500:62:0;;:::i;:::-;1304:12178:15;;;-1:-1:-1;;;;;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;3052:40:0;1304:12178:15;;3052:40:0;1304:12178:15;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;1724:66;;1304:12178;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;-1:-1:-1;;;;;1304:12178:15;;:::i;:::-;;-1:-1:-1;1304:12178:15;;;6969:12:12;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;;;;1304:12178:15;;;-1:-1:-1;;;;;;1304:12178:15;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;2466:103:8;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;8979:19;;;1304:12178;8979:19;453:6:11;3770:27;;3769:34;9008:71:15;;-1:-1:-1;;;;;1304:12178:15;;;2003:42;9106:21;;;9216:1262;;;;590:6:11;4384:27;;4383:34;9291:68:15;;9449:21;9488:12;;;9484:42;;9613:37;-1:-1:-1;9613:37:15;;:::i;:::-;9589:61;;;;;9729:28;9725:64;;9216:1262;10537:41;10592:9;;;:46;;;;9216:1262;10588:252;;;9216:1262;-1:-1:-1;1304:12178:15;;11092:63;1304:12178;;;10935:34;1304:12178;1506:2;1304:12178;1506:2;;;:::i;:::-;10935:34;;:::i;:::-;11092:63;:::i;:::-;11279:94;;;;;11290:52;;;;;;;;;;;;:::i;:::-;11279:94;;11387:8;11383:40;;1304:12178;;;;-1:-1:-1;;;;;1304:12178:15;;11521:53;;1304:12178;11521:53;;;1304:12178;11521:53;:::i;:::-;;;;11632:8;;;:39;;;11279:94;11628:143;;11279:94;1857:1:8;3068:21;1899:1;1304:12178:15;;;11781:11;;1304:12178;;:::i;11628:143::-;-1:-1:-1;11751:8:15;;;:::i;:::-;11628:143;;;;;;;11632:39;;-1:-1:-1;11632:39:15;;11383:40;1304:12178;;-1:-1:-1;;;11404:19:15;;1304:12178;11404:19;1304:12178;;11404:19;;;:::i;:::-;;;;11279:94;11345:28;;;;;;;;;;;;:::i;:::-;11279:94;;;10588:252;10671:24;;;;;1304:12178;;-1:-1:-1;;;10671:24:15;;1304:12178;10671:24;1304:12178;;;10671:24;;;;;;;;-1:-1:-1;10671:24:15;590:6:11;11092:63:15;10671:24;;;;;;;10588:252;590:6:11;;1506:2:15;10713:19;;10709:121;;10588:252;;;;;;;;;;10709:121;10772:43;10795:19;;;;10788:27;10795:19;;:::i;:::-;10788:27;:::i;:::-;10772:43;;:::i;:::-;10709:121;;;;10671:24;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;:::i;:::-;;:::i;10592:46::-;526:6:11;4090:36;4089:43;;;-1:-1:-1;10592:46:15;;;9725:64;9766:23;;;-1:-1:-1;9766:23:15;1304:12178;-1:-1:-1;9766:23:15;9484:42;9509:17;;;-1:-1:-1;9509:17:15;1304:12178;-1:-1:-1;9509:17:15;9291:68;9332:27;;;-1:-1:-1;9332:27:15;1304:12178;-1:-1:-1;9332:27:15;9216:1262;9885:35;;;;;;;;;1304:12178;;-1:-1:-1;;;9885:35:15;;9909:10;1304:12178;9885:35;;1304:12178;;9885:35;1304:12178;;;9885:35;;;;;;;;-1:-1:-1;9885:35:15;;;9216:1262;9875:45;;10007:37;;-1:-1:-1;10007:37:15;;:::i;:::-;9983:61;;;10123:28;;;10119:66;;10314:7;10453:13;10307:4;;9909:10;;10314:7;;:::i;:::-;10453:13;;;:::i;:::-;9216:1262;;10119:66;10160:25;;;-1:-1:-1;10160:25:15;1304:12178;-1:-1:-1;10160:25:15;9885:35;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;9008:71;9049:30;;;-1:-1:-1;9049:30:15;1304:12178;-1:-1:-1;9049:30:15;1304:12178;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;3770:27:11;3769:34;4795:68:12;;1304:12178:15;-1:-1:-1;1304:12178:15;4800:12:12;1304:12178:15;;;-1:-1:-1;1304:12178:15;;;;;;;;4916:19:12;-1:-1:-1;4916:19:12;;1304:12178:15;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;;1304:12178:15;-1:-1:-1;1304:12178:15;;;;;;;;;;;;2763:70:11;2788:45;2795:37;2802:29;702:12;1304:12178:15;;:::i;:::-;7306:12:12;2572:27:11;;2571:34;;1304:12178:15;;526:6:11;2645:36;;2644:43;;1304:12178:15;2615:26:11;;1304:12178:15;;2720:27:11;;2719:34;;1304:12178:15;2697:19:11;;1304:12178:15;2572:27:11;2803:22;590:6;1304:12178:15;;;;702:12:11;2802:29;590:6;;;;2795:37;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;702:12:11;2788:45;-1:-1:-1;;;;;;1304:12178:15;2763:22:11;;;1304:12178:15;;2763:70:11;1304:12178:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;1304:12178:15;;;;;;:::i;:::-;1500:62:0;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;2627:22:0;;2623:91;;-1:-1:-1;1304:12178:15;;-1:-1:-1;;;;;;1304:12178:15;;;;;;-1:-1:-1;;;;;1304:12178:15;;3052:40:0;;-1:-1:-1;3052:40:0;1304:12178:15;2623:91:0;2672:31;;;-1:-1:-1;2672:31:0;-1:-1:-1;1304:12178:15;;;-1:-1:-1;2672:31:0;1304:12178:15;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;1500:62:0;;;;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;;3654:19:12;;3650:46;;1304:12178:15;;3710:27:12;3706:62;;-1:-1:-1;;;;;;1304:12178:15;;3782:36:12;3778:74;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;;3866:34:12;;:19;;;1304:12178:15;3866:34:12;3862:71;;4267:19;4289:13;4318:53;1304:12178:15;4038:218:12;4267:35;1304:12178:15;4038:218:12;1304:12178:15;;:::i;:::-;3866:12:12;1304:12178:15;;4038:218:12;1304:12178:15;;;4038:218:12;;;1304:12178:15;;;4038:218:12;;;1304:12178:15;;4038:218:12;4289:13;:::i;4267:35::-;4318:53;4038:218;1304:12178:15;4318:53:12;;;;;:::i;:::-;;;;1500:62:0:o;3862:71:12:-;3909:24;;;3671:1;3909:24;;3671:1;3909:24;3706:62;3746:22;;;3671:1;3746:22;;3671:1;3746:22;3650:46;3682:14;;;3671:1;3682:14;;3671:1;3682:14;1304:12178:15;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;1506:2;1304:12178;;1506:2;1304:12178;;;;:::o;:::-;-1:-1:-1;;1304:12178:15;;;;;;;;:::o;4470:442::-;;4673:13;;4669:49;;4745:17;;4744:30;4745:17;;;:::i;:::-;4744:30;:::i;:::-;1304:12178;;;;;;;;;4833:17;;;4470:442;:::o;4669:49::-;-1:-1:-1;4696:10:15;;;;4685:1;;4688:30::o;1304:12178::-;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;-1:-1:-1;1304:12178:15;;;;;;;;;;;;;;;;;:::o;3706:324::-;;;3895:13;;3891:37;;3955:17;;3954:30;3955:17;;;:::i;3954:30::-;1304:12178;;;;;;;;;3706:324;:::o;3891:37::-;3910:18;3907:1;3910:18;:::o;1796:162:0:-;1710:6;1304:12178:15;-1:-1:-1;;;;;1304:12178:15;735:10:7;1855:23:0;1851:101;;1796:162::o;1851:101::-;1901:40;;;1710:6;1901:40;735:10:7;1901:40:0;1304:12178:15;;1710:6:0;1901:40;1795:473:11;1304:12178:15;;;;1924:53:11;;1795:473;1991:26;;;1304:12178:15;1987:69:11;;1795:473;2070:19;;;1304:12178:15;2066:53:11;;1795:473;2231:22;;590:6;1304:12178:15;;;;2206:55:11;;1795:473::o;2066:53::-;590:6;2091:28;;;;2066:53;;1987:69;2019:37;526:6;2019:37;1987:69;;;1924:53;453:6;;-1:-1:-1;1924:53:11;;2575:307:8;2702:7;1304:12178:15;;2702:18:8;2698:86;;2702:7;1899:1;;2575:307::o;2698:86::-;2743:30;;;-1:-1:-1;2743:30:8;;-1:-1:-1;2743:30:8;1304:12178:15;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;590:6:11;;;1304:12178:15;;;;;:::o;1506:2::-;;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;1304:12178;;;;;;;:::i;:::-;1506:2;;;-1:-1:-1;1506:2:15;;;;:::o;:::-;1304:12178;1506:2;:::o;:::-;;;;;;1304:12178;;1506:2;;;;;;;;:::i;8618:3181::-;;;;;;8979:19;;;1304:12178;;;;;;;;5340:12:12;1304:12178:15;;;;;;;8979:19;9013:27;453:6:11;3770:27;;3769:34;9008:71:15;;-1:-1:-1;;;;;1304:12178:15;;2003:42;9106:21;;;1304:12178;;;9216:1262;;;;590:6:11;4384:27;;4383:34;9291:68:15;;9449:21;9488:12;;;9484:42;;9613:37;;;;:::i;:::-;9589:61;;;;;9729:28;9725:64;;9216:1262;10537:41;;10592:9;;;:46;;;;9216:1262;10588:252;;;9216:1262;1506:2;11092:63;1506:2;-1:-1:-1;1506:2:15;10935:34;1506:2;;;;;;;:::i;11092:63::-;11279:94;;;;;11290:52;;;;;;;;;;;;:::i;:::-;11279:94;;11387:8;11383:40;;1304:12178;;-1:-1:-1;;;;;1304:12178:15;;;;11521:53;;1304:12178;11521:53;;;1304:12178;11521:53;:::i;:::-;;;;11632:8;;;:39;;;11279:94;11628:143;;11279:94;11781:11;;;;;;8618:3181;:::o;11628:143::-;11751:8;;;:::i;:::-;11628:143;;;;;;;;11632:39;-1:-1:-1;;;;;;1304:12178:15;;11644:27;;11632:39;;11383:40;1304:12178;;-1:-1:-1;;;11404:19:15;;1304:12178;11404:19;1304:12178;11404:19;;;;:::i;11279:94::-;11345:28;;;;;;;;;;;;:::i;:::-;11279:94;;;10588:252;10671:24;;;;;;;1304:12178;;-1:-1:-1;;;10671:24:15;;1304:12178;10671:24;1304:12178;10671:24;1304:12178;10671:24;;;;;;;;-1:-1:-1;10671:24:15;;590:6:11;10671:24:15;;11092:63;10671:24;;;;;10588:252;590:6:11;;1506:2:15;10713:19;;10709:121;;10588:252;;;;;;;;;;;10709:121;10935:34;10795:19;;;10788:27;10795:19;10772:43;10795:19;;:::i;10788:27::-;10772:43;;:::i;:::-;10709:121;;;;10671:24;;;;;;;;;;;;;;:::i;:::-;;;;10592:46;526:6:11;4090:36;4089:43;;;-1:-1:-1;10592:46:15;;;9216:1262;9885:35;;;;;;;;1304:12178;;-1:-1:-1;;;9885:35:15;;9909:10;9885:35;;;1304:12178;;9885:35;1304:12178;;;9885:35;;;;;;;;-1:-1:-1;9885:35:15;;;9216:1262;9875:45;10007:37;9875:45;10007:37;;;:::i;:::-;9983:61;;;10123:28;;;10119:66;;10314:7;10453:13;10307:4;;9909:10;10314:7;;:::i;:::-;10453:13;;;:::i;:::-;9216:1262;;9885:35;;;;;;;;;;;;;;;:::i;:::-;;;;;12063:502;;;12249:13;;12245:62;;12333:30;12334:17;;;;;:::i;12333:30::-;1304:12178;;;;;;;;;12467:18;;;12463:96;;12063:502;;:::o;12463:96::-;12508:40;;;12261:1;12508:40;;1304:12178;;;;12261:1;12508:40;12245:62;12278:18;;;12261:1;12278:18;:::o;1618:188:6:-;1304:12178:15;;-1:-1:-1;;;1745:53:6;;;;-1:-1:-1;;;;;1304:12178:15;;;1745:53:6;;;1304:12178:15;;;;;;;;;;;;;;;;;1745:53:6;;;;;;;1304:12178:15;1745:53:6;:::i;:::-;;:::i;1304:12178:15:-;;344:2:10;1304:12178:15;;;;;;;:::o;3146:225:6:-;;-1:-1:-1;;;;;1304:12178:15;;;3146:225:6;3265:39;;;;;1304:12178:15;;-1:-1:-1;;;3265:39:6;;3289:4;3265:39;;;1304:12178:15;-1:-1:-1;;;;;1304:12178:15;;;;;;;;;;;3265:39:6;;1304:12178:15;;3265:39:6;;;;;;;-1:-1:-1;3265:39:6;;;3146:225;3343:20;1304:12178:15;;;;;;;3343:20:6;;;:::i;3265:39::-;;;;;1304:12178:15;3265:39:6;1304:12178:15;3265:39:6;;;;;;;:::i;:::-;;;;;7658:500:12;;7769:1;1304:12178:15;;7751:19:12;7747:91;;7880:77;;;7992:19;8044:33;7992:37;1304:12178:15;7992:19:12;;1304:12178:15;;;;;;;;5340:12:12;1304:12178:15;;;;;;;7992:19:12;1304:12178:15;;;;-1:-1:-1;;;;;;1304:12178:15;;3075:153:11;7992:37:12;-1:-1:-1;;;;;;1304:12178:15;;;8044:33:12;-1:-1:-1;;;;;;1304:12178:15;;8044:33:12;8040:112;;7658:500;;:::o;8040:112::-;-1:-1:-1;;;;8100:41:12;-1:-1:-1;;;;;1304:12178:15;7769:1:12;1304:12178:15;-1:-1:-1;;;;;;1304:12178:15;;;;-1:-1:-1;8100:41:12;7747:91;1304:12178:15;;-1:-1:-1;;;7779:59:12;;1304:12178:15;7769:1:12;7779:59;;1304:12178:15;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;7779:59:12;;;1524:1476:10;1506:2:15;1524:1476:10;1506:2:15;;;:::i;:::-;1915::10;1304:12178:15;;1899:18:10;1895:180;;2338:13;2350:1;2333:637;2386:15;2358:26;1304:12178:15;;2358:26:10;:::i;:::-;2353:31;;;;344:2;2444:217;;;;1724:66:15;;;2444:217:10;;2679:20;2675:285;;2386:15;;;;;;:::i;:::-;2338:13;;;;2675:285;2719:171;;;1524:1476;:::o;2353:31::-;;;;1524:1476;:::o;1895:180::-;1304:12178:15;;-1:-1:-1;;;1940:124:10;;1304:12178:15;1940:124:10;;;1304:12178:15;;1915:2:10;1304:12178:15;;;;;;;;;;;;;-1:-1:-1;;;1304:12178:15;;;;1940:124:10;;;12934:546:15;;;;;;;13152:238;;;;13204:42;;;;1304:12178;-1:-1:-1;;;;;1304:12178:15;;13204:42;;;;:::i;:::-;;13264:14;13260:45;;13404:69;13152:238;;1304:12178;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1304:12178:15;;;;;;;;13404:69;12934:546::o;13260:45::-;13287:18;;;13204:42;13287:18;;13204:42;13287:18;13152:238;1304:12178;;-1:-1:-1;;;1328:43:6;;;;-1:-1:-1;;;;;1304:12178:15;;1328:43:6;;;1304:12178:15;;;;;;;13404:69;;1304:12178;1328:43:6;;;1304:12178:15;;;;1328:43:6;;1304:12178:15;;1328:43:6;;;;;;:::i;:::-;-1:-1:-1;;;;;1304:12178:15;;1328:43:6;:::i;:::-;13152:238:15;;8370:720:6;;-1:-1:-1;8507:421:6;8370:720;8507:421;;;;;;;;;;;;-1:-1:-1;8507:421:6;;8942:15;;-1:-1:-1;;;;;;1304:12178:15;;8960:26:6;:31;8942:68;8938:146;;8370:720;:::o;8938:146::-;-1:-1:-1;;;;9033:40:6;;;-1:-1:-1;;;;;1304:12178:15;;;;9033:40:6;1304:12178:15;;;9033:40:6;8942:68;9009:1;8994:16;;8942:68;;5084:380;1304:12178:15;;-1:-1:-1;;;5199:47:6;;;;;;;-1:-1:-1;;;;;1304:12178:15;;5199:47:6;;;1304:12178:15;;;;;;;;;5199:47:6;;;1304:12178:15;;;;-1:-1:-1;;5199:47:6;1304:12178:15;;5199:47:6;:::i;:::-;9770:199;;;;;;;-1:-1:-1;9770:199:6;;;;9985:80;;5084:380;-1:-1:-1;5261:45:6;;-1:-1:-1;5261:45:6;5257:201;;5084:380;;;:::o;5257:201::-;1304:12178:15;;-1:-1:-1;;;5199:47:6;5349:43;;;-1:-1:-1;;;;;1304:12178:15;;;5199:47:6;5349:43;;1304:12178:15;5389:1:6;1304:12178:15;;;;5434:12:6;;5349:43;;;1304:12178:15;;;;5349:43:6;1304:12178:15;5349:43:6;;;:::i;9985:80::-;9997:15;;;-1:-1:-1;9997:15:6;;-1:-1:-1;5261:45:6;-1:-1:-1;;;;;1304:12178:15;;10015:26:6;:30;;9997:67;9985:80;;;9997:67;10063:1;5261:45;10048:16;;9997:67;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"AMOUNT_PLACEHOLDER()","signatureHash4":"0x7f4c4847","signatureHash32":"0x7f4c484733c53a64fd926e21d5e638e182463ef33c3c591fbd23e1994dbb8210"},{"signature":"AMOUNT_PLACEHOLDER_BYTES32()","signatureHash4":"0xfd707046","signatureHash32":"0xfd707046e4047e965602b46aac936e60da5578c7c21ead09e0ba77187572db16"},{"signature":"calculateTickRounding(uint256,uint256)","signatureHash4":"0xeb667c6c","signatureHash32":"0xeb667c6c9ca5a9582e217f01dba438e612091cabe3ca64bf0945d884156113fb"},{"signature":"deposit(address,address,bytes,uint256)","signatureHash4":"0xcd867985","signatureHash32":"0xcd8679856d3ba4fafccc5633f49dc3363def99776176198f749ce873e60387c8"},{"signature":"depositWithTick(address,address,bytes,uint256,uint256,address)","signatureHash4":"0x4cd10b8e","signatureHash32":"0x4cd10b8e855efb3bd9e250c9e7543d1275ccba0808d7b01503c1760519f3c73f"},{"signature":"getAllowedSelector(address)","signatureHash4":"0xb139012d","signatureHash32":"0xb139012d3368f497c806d4f6a5b9385af54eebb3e9177684aca9f923b0fb0087"},{"signature":"getMinimumDepositForTick(uint256)","signatureHash4":"0x26604a43","signatureHash32":"0x26604a43804282f3d65ace8b6443c7d4dc6c01ff8a0348277d92190aef4bbb8e"},{"signature":"getVaultConfig(address)","signatureHash4":"0xde1eb9a3","signatureHash32":"0xde1eb9a39a90e1651ec0a9ba80cb99ca8fdf0674be22daad5cbcc2c7d6be4583"},{"signature":"isVaultRegistered(address)","signatureHash4":"0x105a88e3","signatureHash32":"0x105a88e329a5100267d530ddab2249cb9636919aac54979a460268c55c0f0671"},{"signature":"NATIVE_TOKEN()","signatureHash4":"0x31f7d964","signatureHash32":"0x31f7d964a969235b5e86775acad16e7f26c4196d1695d0ffa484111d4d3d999c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"registerVault(address,string,bytes4,bool,bool)","signatureHash4":"0x2f9182cc","signatureHash32":"0x2f9182ccdda0ea7f6f96fd9c9dde33935870902b107af8a5a29b1c94f0b88f99"},{"signature":"removeVault(address)","signatureHash4":"0xceb68c23","signatureHash32":"0xceb68c23b8a5817b125e17dc82653b284e10c56c8319895a4b4945d726087cf2"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"updateAllowedSelector(address,bytes4)","signatureHash4":"0x42a6f7a5","signatureHash32":"0x42a6f7a5aebced178a74b24e1bfbf4d2debc62cda931846b7aa6ef24b61652a4"},{"signature":"validateAmountForTick(uint256,uint256)","signatureHash4":"0xd28c3804","signatureHash32":"0xd28c38040e6b728e5a33baeb5709b191591cec7ed26ce98bf74082390f05bc99"},{"signature":"vaultAllowsNative(address)","signatureHash4":"0x4bfc5014","signatureHash32":"0x4bfc5014956697f6bb567b7e740262dd7f98ec37f3c0d52526aaa119acab93cd"},{"signature":"vaultConfigs(address)","signatureHash4":"0x3d18b2af","signatureHash32":"0x3d18b2af70646da687b89eb2d788c5fe6b12272c0d7f3252b058f99d1169b6a1"},{"signature":"vaultRequires18Decimals(address)","signatureHash4":"0x476b6acf","signatureHash32":"0x476b6acf75790d4e1aa3ef7bbe3c3d6d4874832c7afec4c97cfcbe7fab5111dd"}],"event":[{"signature":"DustRefunded(address,address,uint256,uint256,uint256)","signatureHash4":"0xeb89cc1a","signatureHash32":"0xeb89cc1a0c6b99cb87f8608d2089862fc42b7f8cb003e2401ea646032177b28c"},{"signature":"FunMediatedDeposit(address,address,uint256,bytes)","signatureHash4":"0x76511bb8","signatureHash32":"0x76511bb8950b82fe2ee5f747e5a7929769055ce5ade161da73b869147b1f5e3f"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"SelectorUpdated(address,bytes4)","signatureHash4":"0xd2f6827d","signatureHash32":"0xd2f6827debfb2832d419a5f1fcc2bf414c1e1df8fdd7a232336079a86d3da181"},{"signature":"VaultRegistered(address,string,bool)","signatureHash4":"0x55e854e5","signatureHash32":"0x55e854e53b29a09bfbe28c9e867d99a35dbcc693f17da80c10b4e4607d747a3a"},{"signature":"VaultRemoved(address)","signatureHash4":"0xe71f3a50","signatureHash32":"0xe71f3a50e5ad81964f352c411f1d45e35438ecd1acecef59ac81d9fbbf6cbc0a"}],"error":[{"signature":"AmountBelowMinimumTick(uint256,uint256)","signatureHash4":"0xd9e38123","signatureHash32":"0xd9e38123271e47d63ca07ef4c3e1f1c2a9b014fffacfe6c627682f5d44a3755c"},{"signature":"DepositFailed(bytes)","signatureHash4":"0xf8e68f23","signatureHash32":"0xf8e68f23d3b33772e986cc9861e94e8fd6b9461d62bc1fb21cd754bbaf726bd3"},{"signature":"DustRefundFailed()","signatureHash4":"0x265fabc6","signatureHash32":"0x265fabc6d7300c15b2efce59f0cdd808c559b20fa55a92b316cbfd270d45de89"},{"signature":"EmptyMethodSignature()","signatureHash4":"0xd92efa40","signatureHash32":"0xd92efa408e67bcffcb911350e99cac32d809bc220b24f830dcce23e92dee4956"},{"signature":"InsufficientETHAmount()","signatureHash4":"0x7671265e","signatureHash32":"0x7671265ea37b9cfb0add2c193e1fd2101061fa076e15ba4c24f52d1a73aadf88"},{"signature":"InsufficientTokenAmount()","signatureHash4":"0x2ec48042","signatureHash32":"0x2ec48042b8c6fdb13e4e36cd613ed1ec7a08c69476d0c68dce9c3e7d870e39e0"},{"signature":"InvalidCalldata(string)","signatureHash4":"0x5a90d3fc","signatureHash32":"0x5a90d3fc3b76ca30a9f58ec1caefa0eba488aad8ec7268a1de8296f3e84e21ac"},{"signature":"InvalidDustRecipient()","signatureHash4":"0xa355f889","signatureHash32":"0xa355f889e39ebff53246937323e8aa1cd6dce37887b2c84339b989d960e9a48f"},{"signature":"InvalidFunctionSelector()","signatureHash4":"0x42868c9b","signatureHash32":"0x42868c9bfc7db026bc1f53a5866302babff297b5cc0fad11b99fe9a62171668c"},{"signature":"InvalidTickSize()","signatureHash4":"0x747a60fb","signatureHash32":"0x747a60fb45e3d6dd7d4c2c70458c7347c7c01f69330efcef87f5495027dd9a35"},{"signature":"InvalidVault()","signatureHash4":"0xd03a6320","signatureHash32":"0xd03a63207f799c8b4a310cf73db481de483ce6543ef24d1f75f918a11e4eae1f"},{"signature":"NoETHInContract()","signatureHash4":"0xacbbf5de","signatureHash32":"0xacbbf5deeadd77312aa966b20759f907fa81e0f1aeae56b3a2ed406b9ba1b152"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"},{"signature":"SafeERC20FailedOperation(address)","signatureHash4":"0x5274afe7","signatureHash32":"0x5274afe73c98b4749fc91ffae6b7b574e7842cb2144a159e9377a5f20b32edf9"},{"signature":"SelectorNotAllowed(address,bytes4)","signatureHash4":"0xebd03c52","signatureHash32":"0xebd03c5266d03f12ce1c6b76148e2bfac8122d63b7a28109f1d8f0152ff0426d"},{"signature":"VaultAlreadyRegistered()","signatureHash4":"0x49d8266e","signatureHash32":"0x49d8266ed321685564e2f3f1c4104c2a0c71ae3e7c24b3293d7c7f414c14b204"},{"signature":"VaultDoesNotSupportNative()","signatureHash4":"0x7ca28857","signatureHash32":"0x7ca28857c20240ba6867e40c250fd98dd7258dfc915d3fde369efb2a5e399721"},{"signature":"VaultNotRegistered()","signatureHash4":"0xeeb4f612","signatureHash32":"0xeeb4f612643f0cd535ec00ea46ad6bac612d5dc2a3586dab06ec43aca29b500e"},{"signature":"VaultNotRegisteredForDeposit()","signatureHash4":"0x077b4faf","signatureHash32":"0x077b4faf2e63142f33e196ff40afae834f305330304ebb02f79b7c3b3a37cbda"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x40b72bB73B1E9380629B205e7880Fa409ae7fcc9"}