{"matchId":"7800710","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2025-07-21T14:33:01Z","creationBytecode":{"onchainBytecode":"0x60a0604052306080523480156012575f5ffd5b506019601d565b6080565b63409feecd1980546001811615603a5763f92ee8a95f526004601cfd5b6001600160401b03808260011c14607b578060011b8355806020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a15b505050565b60805161271a61009f5f395f81816110af0152611193015261271a5ff3fe6080604052600436106102e2575f3560e01c8063715018a611610186578063ae1f6aaf116100dc578063d6c0b2c411610087578063f04e283e11610062578063f04e283e14610993578063f2fde38b146109a6578063fee81cf4146109b9575f5ffd5b8063d6c0b2c4146108ba578063dd62ed3e14610974578063e78cea9214610894575f5ffd5b8063c7a2f1de116100b7578063c7a2f1de14610922578063cd63c4d214610941578063d505accf14610955575f5ffd5b8063ae1f6aaf14610894578063c01e1bd6146108ba578063c3cda52014610903575f5ffd5b80638da5cb5b1161013c5780639ab24eb0116101175780639ab24eb0146108375780639dc29fac14610856578063a9059cbb14610875575f5ffd5b80638da5cb5b1461079d57806391ddadf4146107d057806395d89b41146107f2575f5ffd5b80637ecebe001161016c5780637ecebe00146107105780637f73540c1461074157806384a0e08214610760575f5ffd5b8063715018a6146106d057806376a82342146106d8575f5ffd5b80633a46b1a81161023b57806352d1902d116101f1578063587cde1e116101cc578063587cde1e1461062e5780635c19a95c1461068057806370a082311461069f575f5ffd5b806352d1902d146105cd57806354d1f13d146105e157806354fd4d50146105e9575f5ffd5b8063485cc95511610221578063485cc955146105565780634bf5d7e9146105755780634f1ef286146105ba575f5ffd5b80633a46b1a81461051857806340c10f1914610537575f5ffd5b806323b872dd1161029b5780632b8c49e3116102765780632b8c49e314610414578063313ce567146104335780633644e5151461044e575f5ffd5b806323b872dd146103ce57806325692962146103ed57806328162566146103f5575f5ffd5b8063095ea7b3116102cb578063095ea7b31461036857806318160ddd1461038757806318bf5077146103ad575f5ffd5b806301ffc9a7146102e657806306fdde031461031a575b5f5ffd5b3480156102f1575f5ffd5b50610305610300366004612422565b6109ea565b60405190151581526020015b60405180910390f35b348015610325575f5ffd5b5060408051808201909152600581527f546f776e7300000000000000000000000000000000000000000000000000000060208201525b6040516103119190612461565b348015610373575f5ffd5b506103056103823660046124d7565b610a44565b348015610392575f5ffd5b506805345cdf77eb68f44c545b604051908152602001610311565b3480156103b8575f5ffd5b506103cc6103c73660046124d7565b610ad0565b005b3480156103d9575f5ffd5b506103056103e83660046124ff565b610b70565b6103cc610c55565b348015610400575f5ffd5b5061039f61040f366004612539565b610ca2565b34801561041f575f5ffd5b506103cc61042e3660046124d7565b610ceb565b34801561043e575f5ffd5b5060405160128152602001610311565b348015610459575f5ffd5b50604080518082018252600581527f546f776e7300000000000000000000000000000000000000000000000000000060209182015281517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f81527fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d1958918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc69181019190915246606082015230608082015260a0902061039f565b348015610523575f5ffd5b5061039f6105323660046124d7565b610d83565b348015610542575f5ffd5b506103cc6105513660046124d7565b610dc1565b348015610561575f5ffd5b506103cc610570366004612552565b610e13565b348015610580575f5ffd5b5060408051808201909152600e81527f6d6f64653d74696d657374616d70000000000000000000000000000000000000602082015261035b565b6103cc6105c8366004612583565b6110ad565b3480156105d8575f5ffd5b5061039f611190565b6103cc6111ed565b3480156105f4575f5ffd5b5060408051808201909152600d81527f312e302e302d626574612e313200000000000000000000000000000000000000602082015261035b565b348015610639575f5ffd5b5061065b610648366004612539565b63ff466c9f6004525f526018600c205490565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610311565b34801561068b575f5ffd5b506103cc61069a366004612539565b611226565b3480156106aa575f5ffd5b5061039f6106b9366004612539565b6387a211a2600c9081525f91909152602090205490565b6103cc611233565b3480156106e3575f5ffd5b5061039f6106f2366004612539565b63ff466c9f6004525f526017600c205460301c65ffffffffffff1690565b34801561071b575f5ffd5b5061039f61072a366004612539565b6338377508600c9081525f91909152602090205490565b34801561074c575f5ffd5b5061030561075b366004612539565b611246565b34801561076b575f5ffd5b5061077f61077a3660046124d7565b611250565b6040805165ffffffffffff9093168352602083019190915201610311565b3480156107a8575f5ffd5b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275461065b565b3480156107db575f5ffd5b5060405165ffffffffffff42168152602001610311565b3480156107fd575f5ffd5b5060408051808201909152600581527f544f574e53000000000000000000000000000000000000000000000000000000602082015261035b565b348015610842575f5ffd5b5061039f610851366004612539565b6112b1565b348015610861575f5ffd5b506103cc6108703660046124d7565b6112d0565b348015610880575f5ffd5b5061030561088f3660046124d7565b61131e565b34801561089f575f5ffd5b5073420000000000000000000000000000000000001061065b565b3480156108c5575f5ffd5b507f708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b005473ffffffffffffffffffffffffffffffffffffffff1661065b565b34801561090e575f5ffd5b506103cc61091d366004612611565b6113ab565b34801561092d575f5ffd5b5061039f61093c366004612665565b611554565b34801561094c575f5ffd5b5061039f611586565b348015610960575f5ffd5b506103cc61096f36600461267c565b6115a5565b34801561097f575f5ffd5b5061039f61098e366004612552565b6117bb565b6103cc6109a1366004612539565b61183b565b6103cc6109b4366004612539565b611875565b3480156109c4575f5ffd5b5061039f6109d3366004612539565b63389a75e1600c9081525f91909152602090205490565b7fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00602052604081205460ff165b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff83166e22d473030f116ddee9f6b43ac78ba31882191517610a8257633f68539a5f526004601cfd5b82602052637f5e9f20600c52335f52816034600c2055815f52602c5160601c337f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560205fa350600192915050565b3373420000000000000000000000000000000000002814610b1457610b147f82b429000000000000000000000000000000000000000000000000000000000061189b565b610b1e82826118a3565b604051818152339073ffffffffffffffffffffffffffffffffffffffff8416907fde22baff038e3a3e08407cbdf617deed74e869a7ba517df611e33131c6e6ea04906020015b60405180910390a35050565b5f610b7c848484611931565b8360601b6e22d473030f116ddee9f6b43ac78ba33314610bd05733602052637f5e9f208117600c526034600c208054801915610bcd5780851115610bc7576313be252b5f526004601cfd5b84810382555b50505b6387a211a28117600c526020600c20805480851115610bf65763f4d678b85f526004601cfd5b84810382555050835f526020600c208381540181555082602052600c5160601c8160601c7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a350610c4b848484611988565b5060019392505050565b5f6202a30067ffffffffffffffff164201905063389a75e1600c52335f52806020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f5fa250565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c36020526040812054610a3e565b3373420000000000000000000000000000000000002814610d2f57610d2f7f82b429000000000000000000000000000000000000000000000000000000000061189b565b610d398282611993565b604051818152339073ffffffffffffffffffffffffffffffffffffffff8416907fb90795a66650155983e242cac3e1ac1a4dc26f8ed2987f3ce416a34e00111fd490602001610b64565b5f4265ffffffffffff168210610d9b57610d9b611a26565b610dba610db48463ff466c9f6004525f526017600c2090565b83611a33565b9392505050565b3373420000000000000000000000000000000000001014610e0557610e057f82b429000000000000000000000000000000000000000000000000000000000061189b565b610e0f82826118a3565b5050565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf6011328054600382558015610e645760018160011c14303b10610e5b5763f92ee8a95f526004601cfd5b818160ff1b1b91505b50610e6e82611b01565b7f708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b0080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff8516179055610ed962278d00611b64565b610f027f36372b0700000000000000000000000000000000000000000000000000000000611b8c565b610f2b7fa219a02500000000000000000000000000000000000000000000000000000000611b8c565b610f547f9d8ff7da00000000000000000000000000000000000000000000000000000000611b8c565b610f7d7fda287a1d00000000000000000000000000000000000000000000000000000000611b8c565b610fa67f01ffc9a700000000000000000000000000000000000000000000000000000000611b8c565b610fcf7fe90fb3f600000000000000000000000000000000000000000000000000000000611b8c565b610ff87fec4fc8e300000000000000000000000000000000000000000000000000000000611b8c565b6110217f1d1d8b6300000000000000000000000000000000000000000000000000000000611b8c565b61104a7f54fd4d5000000000000000000000000000000000000000000000000000000000611b8c565b6110737f3333199400000000000000000000000000000000000000000000000000000000611b8c565b80156110a8576002815560016020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a15b505050565b7f00000000000000000000000000000000000000000000000000000000000000003081036110e257639f03a0265f526004601cfd5b6110eb84611ce1565b8360601b60601c93503d5f526352d1902d6001527f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80602060016004601d895afa5114611140576355299b496001526004601dfd5b847fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f38a2849055811561118a57604051828482375f388483885af4611188573d5f823e3d81fd5b505b50505050565b5f7f00000000000000000000000000000000000000000000000000000000000000003081146111c657639f03a0265f526004601cfd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc91505090565b63389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f5fa2565b6112303382611ce9565b50565b61123b611d80565b6112445f611db5565b565b5f610a3e82611e1a565b5f5f5f6112698563ff466c9f6004525f526017600c2090565b9050805460a01b60d01c8410611286576386df9d105f526004601cfd5b8381015465ffffffffffff8116935060601c91503082036112a957808401195491505b509250929050565b5f610a3e6112cb8363ff466c9f6004525f526017600c2090565b611ec0565b3373420000000000000000000000000000000000001014611314576113147f82b429000000000000000000000000000000000000000000000000000000000061189b565b610e0f8282611993565b5f61132a338484611931565b6387a211a2600c52335f526020600c208054808411156113515763f4d678b85f526004601cfd5b83810382555050825f526020600c208281540181555081602052600c5160601c337fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a36113a2338484611988565b50600192915050565b60408051808201909152600581527f546f776e730000000000000000000000000000000000000000000000000000006020909101525f7fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d19587fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc64287101561143857633480e9e15f526004601cfd5b6040517fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf5f528960601b60601c602052886040528760605260805f206040526119015f527f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f815282602082015281604082015246606082015230608082015260a081206020526042601e205f528660ff1660205285604052846060526020600160805f60015afa51935080604052505f6060523d159650868861150c856338377508600c9081525f91909152602090205490565b18171561152057631838d95c5f526004601cfd5b61153f836338377508600c52805f526020600c20805460010181555050565b611549838a611ce9565b505050505050505050565b5f4265ffffffffffff16821061156c5761156c611a26565b610a3e6fff466c9f00000000000000000000000083611a33565b5f6115a06fff466c9f000000000000000000000000611ec0565b905090565b73ffffffffffffffffffffffffffffffffffffffff86166e22d473030f116ddee9f6b43ac78ba318851915176115e257633f68539a5f526004601cfd5b60408051808201909152600581527f546f776e730000000000000000000000000000000000000000000000000000006020909101527fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d19587fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc64286101561166e57631a15a3cc5f526004601cfd5b6040518960601b60601c99508860601b60601c985065383775081901600e52895f526020600c2080547f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f835284602084015283604084015246606084015230608084015260a08320602e527f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c983528b60208401528a60408401528960608401528060808401528860a084015260c08320604e526042602c205f528760ff16602052866040528560605260208060805f60015afa8c3d51146117565763ddafbaef5f526004601cfd5b019055777f5e9f20000000000000000000000000000000000000000089176040526034602c20889055888a7f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925602060608501a360405250505f60605250505050505050565b5f7fffffffffffffffffffffffffffffffffffdd2b8cfcf0ee922116094bc538745d73ffffffffffffffffffffffffffffffffffffffff83160161182057507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff610a3e565b50602052637f5e9f20600c9081525f91909152603490205490565b611843611d80565b63389a75e1600c52805f526020600c20805442111561186957636f5e88185f526004601cfd5b5f905561123081611db5565b61187d611d80565b8060601b61189257637448fbae5f526004601cfd5b61123081611db5565b805f5260045ffd5b6118ae5f8383611931565b6805345cdf77eb68f44c54818101818110156118d15763e5cfe9575f526004601cfd5b806805345cdf77eb68f44c5550506387a211a2600c52815f526020600c208181540181555080602052600c5160601c5f7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a3610e0f5f8383611988565b73ffffffffffffffffffffffffffffffffffffffff83161580159061195a575061195a83611e1a565b156110a8576110a87f55c421950000000000000000000000000000000000000000000000000000000061189b565b6110a8838383611f0a565b61199e825f83611931565b6387a211a2600c52815f526020600c208054808311156119c55763f4d678b85f526004601cfd5b82900390556805345cdf77eb68f44c805482900390555f81815273ffffffffffffffffffffffffffffffffffffffff83167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602083a3610e0f825f83611988565b63f98744645f526004601cfd5b5f5f835460a01b60d01c60068110611aa757601061ffff821160041b82811c60ff1060031b17600190811c9190911b80830401811c80830401811c80830401811c80830401811c80830401811c80830401901c81038581015465ffffffffffff168510611aa4576001019150611aa7565b90505b5b80821015611ad95780820160011c65ffffffffffff86820154168510611ad2576001019150611aa8565b9050611aa8565b8460018203019150815460601c81151502925050308203611afa5780195491505b5092915050565b73ffffffffffffffffffffffffffffffffffffffff167fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927819055805f7f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08180a350565b611230817ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c155565b7fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00602052604090205460ff16611c60577fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b006020526040902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055611c92565b6040517ff2cfeefa00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040517fffffffff000000000000000000000000000000000000000000000000000000008216907f78f84e5b1c5c05be2b5ad3800781dd404d6d6c6302bc755c0fe20f58a33a7f22905f90a250565b611230611d80565b63ff466c9f6004525f8290526018600c205473ffffffffffffffffffffffffffffffffffffffff80831690821603611d4457611d447f09ca3c9c0000000000000000000000000000000000000000000000000000000061189b565b73ffffffffffffffffffffffffffffffffffffffff8216611d6d57611d6883611fc6565b611d76565b611d7683612089565b6110a88383612177565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927543314611244576382b429005f526004601cfd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927805473ffffffffffffffffffffffffffffffffffffffff9092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a355565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c260205260408120547ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c19060ff1615611e915750600192915050565b73ffffffffffffffffffffffffffffffffffffffff9092165f9081526002909201602052506040902054421090565b5f815460a01b60d01c90508015611f0557017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01805460601c308103611f0557508019545b919050565b73ffffffffffffffffffffffffffffffffffffffff8316611f4d57611f4a6fff466c9f0000000000000000000000004265ffffffffffff168360016121d7565b50505b73ffffffffffffffffffffffffffffffffffffffff8216611f8f57611f8c6fff466c9f0000000000000000000000004265ffffffffffff16835f6121d7565b50505b6110a8611fa98463ff466c9f6004525f526018600c205490565b611fc08463ff466c9f6004525f526018600c205490565b83612305565b7ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c180545f90611ff590426126e2565b73ffffffffffffffffffffffffffffffffffffffff84165f818152600185016020908152604080832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001690556002870182528083208590555184815293945090927fe16066c96aababa72475f0b2768d3b6181ea150033042b37d0646737caa4a501910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff81165f8181527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c26020908152604080832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660019081179091557ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c3835281842084905590519283527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c193909290917fe16066c96aababa72475f0b2768d3b6181ea150033042b37d0646737caa4a5019101610b64565b5f8160601b60601c63ff466c9f600452835f526018600c2080549250818155508082600c5160601c7f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f5f5fa4506110a881836121d286612409565b612305565b5f5f85548060a01b60d01c8061223d57851585176121fc57635915f6865f526004601cfd5b8592508260a01c3084141761222257606083901b871766010000000000001788556122fa565b3060601b8717660100000000000017885587198390556122fa565b87600182030180548060601c95503086036122585781195495505b866122775787860394508585111561229157635915f6865f526004601cfd5b87860194508585101561229157639dbbeb755f526004601cfd5b65ffffffffffff168881146122b857660100000000000084018a5560019283019291909101905b8260301c89821117156122c757fe5b508360a01c308514176122e7578360601b8260301b8917178155506122fa565b3060601b8260301b891717815583811955505b505094509492505050565b8061230f57505050565b73ffffffffffffffffffffffffffffffffffffffff808416908316808203612338575050505050565b811561239d575f5f6123696123598863ff466c9f6004525f526017600c2090565b4265ffffffffffff16875f6121d7565b91509150815f5280602052837fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72460405fa250505b8015611188575f5f6123cf6123be8763ff466c9f6004525f526017600c2090565b4265ffffffffffff168760016121d7565b91509150815f5280602052827fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72460405fa250505050505050565b6387a211a2600c9081525f828152602090912054610a3e565b5f60208284031215612432575f5ffd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114610dba575f5ffd5b602081525f82518060208401528060208501604085015e5f6040828501015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505092915050565b803573ffffffffffffffffffffffffffffffffffffffff81168114611f05575f5ffd5b5f5f604083850312156124e8575f5ffd5b6124f1836124b4565b946020939093013593505050565b5f5f5f60608486031215612511575f5ffd5b61251a846124b4565b9250612528602085016124b4565b929592945050506040919091013590565b5f60208284031215612549575f5ffd5b610dba826124b4565b5f5f60408385031215612563575f5ffd5b61256c836124b4565b915061257a602084016124b4565b90509250929050565b5f5f5f60408486031215612595575f5ffd5b61259e846124b4565b9250602084013567ffffffffffffffff8111156125b9575f5ffd5b8401601f810186136125c9575f5ffd5b803567ffffffffffffffff8111156125df575f5ffd5b8660208284010111156125f0575f5ffd5b939660209190910195509293505050565b803560ff81168114611f05575f5ffd5b5f5f5f5f5f5f60c08789031215612626575f5ffd5b61262f876124b4565b9550602087013594506040870135935061264b60608801612601565b9598949750929560808101359460a0909101359350915050565b5f60208284031215612675575f5ffd5b5035919050565b5f5f5f5f5f5f5f60e0888a031215612692575f5ffd5b61269b886124b4565b96506126a9602089016124b4565b955060408801359450606088013593506126c560808901612601565b9699959850939692959460a0840135945060c09093013592915050565b80820180821115610a3e577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd","recompiledBytecode":"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","sourceMap":"1376:9469:6:-:0;;;1525:4:23;1466:66;;3440:47:6;;;;;;;;;-1:-1:-1;3460:22:6;:20;:22::i;:::-;1376:9469;;7118:736:22;-1:-1:-1;;7294:8:22;;7325:1;7318:9;;7315:134;;;7359:10;7353:4;7346:24;7430:4;7424;7417:18;7315:134;-1:-1:-1;;;;;7534:9:22;7530:1;7527;7523:9;7520:24;7510:328;;7662:9;7659:1;7655:17;7652:1;7645:28;7752:9;7746:4;7739:23;7796:27;7790:4;7784;7779:45;7510:328;;;7271:577;7118:736::o;1376:9469:6:-;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1376:9469:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6757:148;;;;;;;;;;-1:-1:-1;6757:148:6;;;;;:::i;:::-;;:::i;:::-;;;516:14:24;;509:22;491:41;;479:2;464:18;6757:148:6;;;;;;;;7720:83;;;;;;;;;;-1:-1:-1;7794:4:6;;;;;;;;;;;;;;;;;7720:83;;;;;;;:::i;8175:1029:20:-;;;;;;;;;;-1:-1:-1;8175:1029:20;;;;;:::i;:::-;;:::i;6907:195::-;;;;;;;;;;-1:-1:-1;7067:18:20;7061:25;6907:195;;;1677:25:24;;;1665:2;1650:18;6907:195:20;1531:177:24;5922:179:6;;;;;;;;;;-1:-1:-1;5922:179:6;;;;;:::i;:::-;;:::i;:::-;;11165:4753:20;;;;;;;;;;-1:-1:-1;11165:4753:20;;;;;:::i;:::-;;:::i;9021:617:19:-;;;:::i;7308:131:6:-;;;;;;;;;;-1:-1:-1;7308:131:6;;;;;:::i;:::-;;:::i;6265:185::-;;;;;;;;;;-1:-1:-1;6265:185:6;;;;;:::i;:::-;;:::i;7898:77::-;;;;;;;;;;-1:-1:-1;7898:77:6;;7968:2;2425:36:24;;2413:2;2398:18;7898:77:6;2283:184:24;21458:737:20;;;;;;;;;;-1:-1:-1;2419:4:6;;;;;;;;;;;;;;;;;21877:11:20;;21944:16;21934:27;;2403:22:6;21981:12:20;;;21974:30;;;;5177:66;22024:12;;;22017:33;;;;22084:9;22077:4;22070:12;;22063:31;22128:9;22121:4;22114:12;;22107:31;22174:4;22161:18;;21458:737;;5912:294:21;;;;;;;;;;-1:-1:-1;5912:294:21;;;;;:::i;:::-;;:::i;8144:145:6:-;;;;;;;;;;-1:-1:-1;8144:145:6;;;;;:::i;:::-;;:::i;3491:806::-;;;;;;;;;;-1:-1:-1;3491:806:6;;;;;:::i;:::-;;:::i;8920:101::-;;;;;;;;;;-1:-1:-1;8993:23:6;;;;;;;;;;;;;;;;;8920:101;;4017:1618:23;;;;;;:::i;:::-;;:::i;3584:227::-;;;;;;;;;;;;;:::i;9720:456:19:-;;;:::i;4367:98:6:-;;;;;;;;;;-1:-1:-1;4438:22:6;;;;;;;;;;;;;;;;;4367:98;;6277:305:21;;;;;;;;;;-1:-1:-1;6277:305:21;;;;;:::i;:::-;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;;;;3760:42:24;3748:55;;;3730:74;;3718:2;3703:18;6277:305:21;3584:226:24;6655:101:21;;;;;;;;;;-1:-1:-1;6655:101:21;;;;;:::i;:::-;;:::i;7168:286:20:-;;;;;;;;;;-1:-1:-1;7168:286:20;;;;;:::i;:::-;7336:18;7330:4;7323:32;;;7231:14;7368:19;;;;7432:4;7416:21;;7410:28;;7168:286;8762:100:19;;;:::i;9456:274:21:-;;;;;;;;;;-1:-1:-1;9456:274:21;;;;;:::i;:::-;15244:29;15238:4;15231:43;9527:14;15287:21;15347:4;15341;15331:21;9699:13;9681:33;;;;;9456:274;17137:340:20;;;;;;;;;;-1:-1:-1;17137:340:20;;;;;:::i;:::-;17360:17;17354:4;17347:31;;;17197:14;17391:19;;;;17455:4;17439:21;;17433:28;;17137:340;7188:116:6;;;;;;;;;;-1:-1:-1;7188:116:6;;;;;:::i;:::-;;:::i;9807:797:21:-;;;;;;;;;;-1:-1:-1;9807:797:21;;;;;:::i;:::-;;:::i;:::-;;;;4017:14:24;4005:27;;;3987:46;;4064:2;4049:18;;4042:34;;;;3960:18;9807:797:21;3815:267:24;11408:182:19;;;;;;;;;;-1:-1:-1;11562:11:19;11556:18;11408:182;;8738:96:6;;;;;;;;;;-1:-1:-1;8738:96:6;;4261:14:24;8813:15:6;4249:27:24;4231:46;;4219:2;4204:18;8738:96:6;4087:196:24;7807:87:6;;;;;;;;;;-1:-1:-1;7883:6:6;;;;;;;;;;;;;;;;;7807:87;;5658:149:21;;;;;;;;;;-1:-1:-1;5658:149:21;;;;;:::i;:::-;;:::i;8462::6:-;;;;;;;;;;-1:-1:-1;8462:149:6;;;;;:::i;:::-;;:::i;9391:1406:20:-;;;;;;;;;;-1:-1:-1;9391:1406:20;;;;;:::i;:::-;;:::i;5042:97:6:-;;;;;;;;;;-1:-1:-1;206:42:7;5042:97:6;;4849:98;;;;;;;;;;-1:-1:-1;769:12:7;4913:29:6;;;4849:98;;6840:2265:21;;;;;;;;;;-1:-1:-1;6840:2265:21;;;;;:::i;:::-;;:::i;10916:254::-;;;;;;;;;;-1:-1:-1;10916:254:21;;;;;:::i;:::-;;:::i;10672:147::-;;;;;;;;;;;;;:::i;17661:3716:20:-;;;;;;;;;;-1:-1:-1;17661:3716:20;;;;;:::i;:::-;;:::i;7549:495::-;;;;;;;;;;-1:-1:-1;7549:495:20;;;;;:::i;:::-;;:::i;10363:708:19:-;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:19;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;6757:148:6;1119:62:17;;;6850:4:6;1119:62:17;;;296:66:18;1119:62:17;;;;;;;;6869:31:6;6862:38;6757:148;-1:-1:-1;;6757:148:6:o;8175:1029:20:-;8249:4;8483:25;;;8510:8;8479:40;8528:11;;8521:19;8476:65;8466:222;;8578:10;8572:4;8565:24;8665:4;8659;8652:18;8466:222;8864:7;8858:4;8851:21;8898:20;8892:4;8885:34;8945:8;8939:4;8932:22;8997:6;8990:4;8984;8974:21;8967:37;9072:6;9066:4;9059:20;9160:4;9154:11;9150:2;9146:20;9136:8;9109:25;9103:4;9097;9092:75;-1:-1:-1;9193:4:20;8175:1029;;;;:::o;5922:179:6:-;3039:10;371:42:7;3039:46:6;3035:113;;3095:46;3119:21;3095:23;:46::i;:::-;6026:19:::1;6032:3;6037:7;6026:5;:19::i;:::-;6056:40;::::0;1677:25:24;;;6085:10:6::1;::::0;6056:40:::1;::::0;::::1;::::0;::::1;::::0;1665:2:24;1650:18;6056:40:6::1;;;;;;;;5922:179:::0;;:::o;11165:4753:20:-;11253:4;11269:38;11290:4;11296:2;11300:6;11269:20;:38::i;:::-;11533:4;11529:2;11525:13;11578:8;11568;11565:22;11555:928;;11694:8;11688:4;11681:22;11747:20;11740:5;11737:31;11731:4;11724:45;11827:4;11821;11811:21;11877:13;11871:20;11993:10;11989:15;11986:479;;;12134:10;12126:6;12123:22;12120:183;;;12189:10;12183:4;12176:24;12272:4;12266;12259:18;12120:183;12435:6;12423:10;12419:23;12404:13;12397:46;11986:479;;;11555:928;12587:18;12580:5;12577:29;12571:4;12564:43;12663:4;12657;12647:21;12710:15;12704:22;12808:11;12800:6;12797:23;12794:158;;;12856:10;12850:4;12843:24;12929:4;12923;12916:18;12794:158;13069:6;13056:11;13052:24;13035:15;13028:49;;;13160:2;13154:4;13147:16;13217:4;13211;13201:21;13483:6;13467:13;13461:20;13457:33;13442:13;13435:56;;13567:6;13561:4;13554:20;13665:4;13659:11;13655:2;13651:20;13643:5;13639:2;13635:14;13608:25;13602:4;13596;13591:81;;15853:37;15873:4;15879:2;15883:6;15853:19;:37::i;:::-;-1:-1:-1;15907:4:20;11165:4753;;;;;:::o;9021:617:19:-;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;7308:131:6:-;1508:49:1;;;7388:7:6;1508:49:1;;;:40;:49;;;;;;7410:24:6;1421:141:1;6265:185:6;3039:10;371:42:7;3039:46:6;3035:113;;3095:46;3119:21;3095:23;:46::i;:::-;6371:21:::1;6377:5;6384:7;6371:5;:21::i;:::-;6403:42;::::0;1677:25:24;;;6434:10:6::1;::::0;6403:42:::1;::::0;::::1;::::0;::::1;::::0;1665:2:24;1650:18;6403:42:6::1;1531:177:24::0;5912:294:21;6031:7;8813:15:6;6058:20:21;;:9;:20;6054:54;;6080:28;:26;:28::i;:::-;6125:74;6154:33;6179:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;6154:33;6189:9;6125:28;:74::i;:::-;6118:81;5912:294;-1:-1:-1;;;5912:294:21:o;8144:145:6:-;2810:10;206:42:7;2810:41:6;2806:108;;2861:46;2885:21;2861:23;:46::i;:::-;8267:17:::1;8273:2;8277:6;8267:5;:17::i;:::-;8144:145:::0;;:::o;3491:806::-;2001:66:22;3768:8;;3866:1;3856:12;;3950:398;;;;4110:1;4106;4103;4099:9;4096:16;4084:9;4072:22;4069:44;4059:189;;4150:10;4144:4;4137:24;4225:4;4219;4212:18;4059:189;4287:1;4283;4278:3;4274:11;4270:19;4265:24;;3950:398;;3609:24:6::1;3626:6;3609:16;:24::i;:::-;769:12:7::0;896:28;;;;;;;;;;3746:24:6::1;3762:7;3746:15;:24::i;:::-;3798:39;3812:24;3798:13;:39::i;:::-;3843:47;3857:32;3843:13;:47::i;:::-;3896:45;3910:30;3896:13;:45::i;:::-;3947:41;3961:26;3947:13;:41::i;:::-;3994:40;4008:25;3994:13;:40::i;:::-;4040:39;4054:24;4040:13;:39::i;:::-;4085:55;4099:40;4085:13;:55::i;:::-;4146:53;4160:38;4146:13;:53::i;:::-;4205:40;4219:25;4205:13;:40::i;:::-;4251:41;4265:26;4251:13;:41::i;:::-;4447:1:22::0;4444:263;;;4548:1;4545;4538:12;4629:1;4623:4;4616:15;4665:27;4659:4;4653;4648:45;4444:263;4430:287;3491:806:6;;:::o;4017:1618:23:-;5755:6;6116:9;6110:16;;6107:143;;6158:10;6152:4;6145:24;6231:4;6225;6218:18;6107:143;4170:36:::1;4188:17;4170;:36::i;:::-;4319:17;4315:2;4311:26;4307:2;4303:35;4282:56;;4389:16;4383:4;4376:30;4432:10;4426:4;4419:24;4487:28;4692:1;4684:4;4678;4672;4666;4647:17;4640:5;4629:60;4623:67;4620:74;4610:199;;4727:10;4721:4;4714:24;4790:4;4784;4777:18;4610:199;4914:17;4887:25;4881:4;4869:10;4864:68;4945:28:::0;;;5103:516;::::1;;;5231:4;5225:11;5282;5269;5266:1;5253:41;5388:4;5376:10;5363:11;5360:1;5341:17;5334:5;5321:72;5311:294;;5522:16;5516:4;5513:1;5498:41;5570:16;5567:1;5560:27;5311:294;;5103:516;5733:544:::0;4017:1618;;;:::o;3584:227::-;3651:7;6450:6;6548:9;6542:16;;6532:151;;6591:10;6585:4;6578:24;6664:4;6658;6651:18;6532:151;2619:66:::1;::::0;-1:-1:-1;6428:282:23;3584:227;:::o;9720:456:19:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;6655:101:21:-;6717:32;6727:10;6739:9;6717;:32::i;:::-;6655:101;:::o;8762:100:19:-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;7188:116:6:-;7258:4;7277:22;7291:7;7277:13;:22::i;9807:797:21:-;9918:22;9942:23;9981:18;10002:33;10027:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;10002:33;9981:54;;10151:10;10145:17;10140:3;10136:27;10131:3;10127:37;10124:1;10121:44;10111:189;;10198:10;10192:4;10185:24;10281:4;10275;10268:18;10111:189;10343:18;;;10337:25;10398:14;10394:37;;;-1:-1:-1;10467:2:21;10463:25;;-1:-1:-1;10524:9:21;10504:30;;10501:87;;10573:10;10570:1;10566:18;10562:23;10556:30;10537:49;;10501:87;10097:501;9807:797;;;;;:::o;5658:149::-;5722:7;5748:52;5766:33;5791:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;5766:33;5748:17;:52::i;8462:149:6:-;2810:10;206:42:7;2810:41:6;2806:108;;2861:46;2885:21;2861:23;:46::i;:::-;8587:19:::1;8593:4;8599:6;8587:5;:19::i;9391:1406:20:-:0;9461:4;9477:44;9498:10;9510:2;9514:6;9477:20;:44::i;:::-;9670:18;9664:4;9657:32;9715:8;9709:4;9702:22;9776:4;9770;9760:21;9819:15;9813:22;9909:11;9901:6;9898:23;9895:146;;;9953:10;9947:4;9940:24;10022:4;10016;10009:18;9895:146;10150:6;10137:11;10133:24;10116:15;10109:49;;;10233:2;10227:4;10220:16;10286:4;10280;10270:21;10536:6;10520:13;10514:20;10510:33;10495:13;10488:56;;10612:6;10606:4;10599:20;10700:4;10694:11;10690:2;10686:20;10676:8;10649:25;10643:4;10637;10632:75;10726:43;10746:10;10758:2;10762:6;10726:19;:43::i;:::-;-1:-1:-1;10786:4:20;9391:1406;;;;:::o;6840:2265:21:-;2419:4:6;;;;;;;;;;;;;;;;;;-1:-1:-1;2403:22:6;5177:66:20;7380:11:21;7377:23;-1:-1:-1;7374:158:21;;;7432:10;7426:4;7419:24;7513:4;7507;7500:18;7374:158;7560:4;7554:11;7631:28;7625:4;7618:42;7702:9;7698:2;7694:18;7690:2;7686:27;7680:4;7673:41;7740:5;7734:4;7727:19;7772:6;7766:4;7759:20;7821:4;7815;7805:21;7799:4;7792:35;7853:6;7847:4;7840:20;7949:16;7946:1;7939:27;8000:8;7993:4;7990:1;7986:12;7979:30;8043:11;8036:4;8033:1;8029:12;8022:33;8089:9;8082:4;8079:1;8075:12;8068:31;8133:9;8126:4;8123:1;8119:12;8112:31;8182:4;8179:1;8169:18;8163:4;8156:32;8277:4;8271;8261:21;8255:4;8248:35;8319:1;8313:4;8309:12;8303:4;8296:26;8348:1;8342:4;8335:15;8376:1;8370:4;8363:15;8446:4;8440;8434;8428;8425:1;8418:5;8407:44;8401:51;8391:61;;8478:1;8472:4;8465:15;;8542:1;8536:4;8529:15;8688:16;8681:24;8671:34;;8804:6;8795:5;8778:14;8785:6;17360:17:20;17354:4;17347:31;;;17197:14;17391:19;;;;17455:4;17439:21;;17433:28;;17137:340;8778:14:21;:22;8777:33;:38;8773:255;;8918:10;8912:4;8905:24;8999:4;8993;8986:18;8773:255;9037:23;9053:6;16833:17:20;16827:4;16820:31;16877:5;16871:4;16864:19;16929:4;16923;16913:21;16978:9;16972:16;16969:1;16965:24;16954:9;16947:43;;16687:319;;9037:23:21;9070:28;9080:6;9088:9;9070;:28::i;:::-;7013:2092;;;6840:2265;;;;;;:::o;10916:254::-;10997:7;8813:15:6;11020:20:21;;:9;:20;11016:54;;11042:28;:26;:28::i;:::-;11087:76;11116:35;11153:9;11087:28;:76::i;10672:147::-;10732:7;10758:54;10776:35;10758:17;:54::i;:::-;10751:61;;10672:147;:::o;17661:3716:20:-;18077:25;;;18104:8;18073:40;18122:10;;18115:18;18070:64;18060:221;;18171:10;18165:4;18158:24;18258:4;18252;18245:18;18060:221;2419:4:6;;;;;;;;;;;;;;;;;;2403:22;5177:66:20;18720:11;18717:25;-1:-1:-1;18714:142:20;;;18774:10;18768:4;18761:24;18837:4;18831;18824:18;18714:142;18884:4;18878:11;19000:5;18996:2;18992:14;18988:2;18984:23;18975:32;;19047:7;19043:2;19039:16;19035:2;19031:25;19020:36;;19140:39;19134:4;19127:53;19206:5;19200:4;19193:19;19258:4;19252;19242:21;19300:9;19294:16;19378;19375:1;19368:27;19429:8;19422:4;19419:1;19415:12;19408:30;19472:11;19465:4;19462:1;19458:12;19451:33;19518:9;19511:4;19508:1;19504:12;19497:31;19562:9;19555:4;19552:1;19548:12;19541:31;19611:4;19608:1;19598:18;19592:4;19585:32;19680:16;19677:1;19670:27;19731:5;19724:4;19721:1;19717:12;19710:27;19771:7;19764:4;19761:1;19757:12;19750:29;19813:5;19806:4;19803:1;19799:12;19792:27;19853:10;19846:4;19843:1;19839:12;19832:32;19898:8;19891:4;19888:1;19884:12;19877:30;19946:4;19943:1;19933:18;19927:4;19920:32;20041:4;20035;20025:21;20019:4;20012:35;20083:1;20077:4;20073:12;20067:4;20060:26;20112:1;20106:4;20099:15;20140:1;20134:4;20127:15;20203:4;20197;20191;20185;20182:1;20175:5;20164:44;20624:5;20605:16;20599:23;20596:34;20586:159;;20663:10;20657:4;20650:24;20726:4;20720;20713:18;20586:159;20830:18;20812:37;;21028:30;21025:43;;21019:4;21012:57;21105:4;21099;21089:21;21082:36;;;21060:7;21225:5;21198:25;-1:-1:-1;21185:4:20;21178:12;;21173:67;21260:4;21253:15;-1:-1:-1;;21330:1:20;21324:4;21317:15;-1:-1:-1;;;;;;;17661:3716:20:o;7549:495::-;7661:14;7746:19;;;;;7742:49;;-1:-1:-1;7774:17:20;7767:24;;7742:49;-1:-1:-1;7884:4:20;7877:21;7924:20;7918:4;7911:34;;;7965:4;7958:19;;;;8022:4;8006:21;;8000:28;;7549:495::o;10363:708:19:-;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;8348:349::-:0;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;602:141:8:-:0;702:8;699:1;692:19;728:4;725:1;718:15;22599:1172:20;22669:44;22698:1;22702:2;22706:6;22669:20;:44::i;:::-;22820:18;22814:25;22899:6;22880:17;22876:30;22996:17;22978:16;22975:39;22972:162;;;23046:10;23040:4;23033:24;23115:4;23109;23102:18;22972:162;23221:16;23201:18;23194:44;;;23324:18;23318:4;23311:32;23369:2;23363:4;23356:16;23422:4;23416;23406:21;23538:6;23522:13;23516:20;23512:33;23497:13;23490:56;;23614:6;23608:4;23601:20;23695:4;23689:11;23685:2;23681:20;23678:1;23651:25;23645:4;23639;23634:68;23721:43;23749:1;23753:2;23757:6;23721:19;:43::i;9302:326:6:-;9418:18;;;;;;;:41;;;9440:19;9454:4;9440:13;:19::i;:::-;9414:159;;;9513:53;9537:28;9513:23;:53::i;11776:180:21:-;11911:38;11932:4;11938:2;11942:6;11911:20;:38::i;24177:1119:20:-;24249:46;24270:4;24284:1;24288:6;24249:20;:46::i;:::-;24444:18;24438:4;24431:32;24489:4;24483;24476:18;24546:4;24540;24530:21;24589:15;24583:22;24679:11;24671:6;24668:23;24665:146;;;24723:10;24717:4;24710:24;24792:4;24786;24779:18;24665:146;24903:24;;;24879:49;;25038:18;25032:25;;25028:38;;;25001:66;;-1:-1:-1;25122:20:20;;;25199:22;;;25172:25;25166:4;-1:-1:-1;25155:70:20;25244:45;25264:4;25278:1;25282:6;25244:19;:45::i;20445:226:21:-;20585:10;20579:4;20572:24;20650:4;20644;20637:18;18722:1666;18839:14;18944:1;18999:10;18993:17;18988:3;18984:27;18979:3;18975:37;19149:1;19146;19143:8;19129:686;;19274:2;19193:6;19190:13;-1:-1:-1;19187:1:21;19183:21;19259:9;;;19253:4;19250:19;19247:1;19243:27;19237:34;19234:1;19230:42;;;19226:51;;;;19313:9;;;19306:17;19299:25;;19360:9;;;19353:17;19346:25;;19407:9;;;19400:17;19393:25;;19454:9;;;19447:17;19440:25;;19501:9;;;19494:17;19487:25;;19555:9;;;19548:17;19541:25;;19534:33;;19637:18;;;19631:25;19658:14;19627:46;19619:55;;19609:147;;19707:1;19703:9;;-1:-1:-1;19733:5:21;;19609:147;19778:1;-1:-1:-1;19129:686:21;19858:298;19871:1;19868;19865:8;19858:298;;;19918:1;19915;19911:9;19908:1;19904:17;20018:14;20004:10;20001:1;19997:18;19991:25;19987:46;19982:3;19979:55;19969:150;;20067:1;20063:9;;-1:-1:-1;19858:298:21;;19969:150;20141:1;-1:-1:-1;19858:298:21;;;20206:10;20202:1;20199;20195:9;20191:26;20169:48;;20277:14;20271:21;20267:2;20263:30;20258:1;20251:9;20244:17;20240:54;20230:64;;;20321:9;20313:6;20310:21;20307:65;;20354:14;20350:19;20344:26;20334:36;;20307:65;;18722:1666;;;;:::o;4883:1190:19:-;5793:26;;5883:11;5876:29;;;5793:26;6031:1;5991:38;6031:1;;5980:63;4883:1190;:::o;294:92:1:-;352:29;372:8;529:12:2;616:47:1;554:114;456:282:17;1119:62;;;1100:4;1119:62;;;296:66:18;1119:62:17;;;;;;;;514:182;;560:62;;;:49;:62;;;296:66:18;560:62:17;;;;;:69;;;;625:4;560:69;;;514:182;;;657:32;;;;;;;;;;;;;;514:182;706:27;;;;;;;;;;;456:282;:::o;10751:92:6:-;12517:13:19;:11;:13::i;9632:524:6:-;6449:29:21;6443:4;6436:43;9711:24:6;6492:23:21;;;6560:4;6554;6544:21;6538:28;9835:29:6;;;;;;;;9831:97;;9872:56;9896:31;9872:23;:56::i;:::-;10008:23;;;10004:106;;10041:21;10054:7;10041:12;:21::i;:::-;10004:106;;;10083:20;10095:7;10083:11;:20::i;:::-;10116:35;10132:7;10141:9;10116:15;:35::i;7292:355:19:-;7504:11;7498:18;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;6145:1089;6857:11;7093:16;;6941:26;;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;1635:247:1:-;1773:28;;;1698:4;1773:28;;;:19;:28;;;;;;529:12:2;;1773:28:1;;1769:45;;;-1:-1:-1;1810:4:1;;1635:247;-1:-1:-1;;1635:247:1:o;1769:45::-;1846:31;;;;;;;;:22;;;;:31;;-1:-1:-1;1846:31:1;;;;1828:15;:49;;1635:247::o;18134:486:21:-;18203:14;18329:10;18323:17;18318:3;18314:27;18309:3;18305:37;18295:47;;18358:6;18355:249;;;18397:31;18401:14;18397:31;18494:17;;18490:2;18486:26;18543:9;18532:21;;18529:61;;-1:-1:-1;18572:15:21;;18566:22;18529:61;18134:486;;;:::o;12048:437::-;12151:18;;;12147:128;;12185:79;12205:35;8813:15:6;12185:79:21;;12251:6;12259:4;12185:19;:79::i;:::-;;;12147:128;12288:16;;;12284:127;;12320:80;12340:35;8813:15:6;12320:80:21;;12386:6;12394:5;12320:19;:80::i;:::-;;;12284:127;12420:58;12439:15;12449:4;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;12439:15;12456:13;12466:2;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;12456:13;12471:6;12420:18;:58::i;1037:318:1:-;529:12:2;1189:18:1;;1091:29;;1171:36;;:15;:36;:::i;:::-;1213:28;;;1244:5;1213:28;;;:19;;;:28;;;;;;;;:36;;;;;;1255:22;;;:31;;;;;:44;;;1311:39;1677:25:24;;;1255:44:1;;-1:-1:-1;1244:5:1;;1311:39;;1650:18:24;1311:39:1;;;;;;;1085:270;;1037:318;:::o;723:234::-;835:28;;;776:29;835:28;;;:19;:28;;;;;;;;:35;;;;866:4;835:35;;;;;;876:22;:31;;;;;:35;;;923:29;;1677:25:24;;;529:12:2;;866:4:1;;835:28;;923:29;;1650:18:24;923:29:1;1531:177:24;14051:660:21;14133:12;14247:9;14243:2;14239:18;14235:2;14231:27;14284:29;14278:4;14271:43;14340:7;14334:4;14327:21;14397:4;14391;14381:21;14429:12;14423:19;14415:27;;14476:2;14462:12;14455:24;;14621:2;14615:4;14607;14601:11;14597:2;14593:20;14558:33;14552:4;14546;14541:83;;14643:61;14662:4;14668:9;14679:24;14695:7;14679:15;:24::i;:::-;14643:18;:61::i;15408:2662::-;15531:16;15549;15677:10;15671:17;15734:16;15729:3;15725:26;15720:3;15716:36;15788:1;15778:668;;15840:6;15833:14;15826:5;15823:25;15813:192;;15889:10;15883:4;15876:24;15978:4;15972;15965:18;15813:192;16038:6;16026:18;;16112:8;16107:3;16103:18;16091:9;16081:8;16078:23;16075:47;16065:199;;16197:2;16193:17;;;16169:42;;16180:10;16169:42;16150:62;;16237:5;;16065:199;16336:9;16332:2;16328:18;16304:43;;16315:10;16304:43;16285:63;;16376:15;;16369:33;;;16423:5;;15778:668;16500:10;16496:1;16493;16489:9;16485:26;16552:14;16546:21;16604:10;16600:2;16596:19;16584:31;;16648:9;16638:8;16635:23;16632:69;;16683:14;16679:19;16673:26;16661:38;;16632:69;16762:5;16752:298;;16821:6;16811:8;16807:21;16795:33;;16876:8;16866;16863:22;16853:43;16889:5;16853:43;16934:10;16928:4;16921:24;17023:4;17017;17010:18;16752:298;17097:6;17087:8;17083:21;17071:33;;17148:8;17138;17135:22;17125:43;17161:5;17125:43;17202:10;17196:4;17189:24;17286:4;17280;17273:18;16718:591;17345:14;17341:31;17399:16;;;17389:217;;17558:10;17554:33;;17535:53;;17448:1;17444:9;;;;17492:22;;;;;17389:217;17655:1;17651:2;17647:10;17641:3;17632:7;17629:16;17626:32;17623:49;;;17661:9;17623:49;;17736:8;17731:3;17727:18;17715:9;17705:8;17702:23;17699:47;17689:191;;17825:8;17821:2;17817:17;17812:1;17808:2;17804:10;17799:3;17796:19;17793:42;17777:14;17770:66;17857:5;;;17689:191;17952:9;17948:2;17944:18;17939:1;17935:2;17931:10;17926:3;17923:19;17920:43;17904:14;17897:67;18009:8;17992:14;17988:19;17981:37;;15701:2353;15705:49;;15408:2662;;;;;;;:::o;12643:1260::-;12744:6;12740:33;;12643:1260;;;:::o;12740:33::-;12826:22;;;;;12850:20;;12885:24;;;12881:37;;12911:7;;12643:1260;;;:::o;12881:37::-;12931:16;;12927:484;;12964:16;12982;13018:75;13038:30;13063:4;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;13038:30;8813:15:6;13018:75:21;;13079:6;13087:5;13018:19;:75::i;:::-;12963:130;;;;13252:8;13246:4;13239:22;13291:8;13285:4;13278:22;13375:11;13334:39;13328:4;13322;13317:70;13163:238;;12927:484;13424:14;;13420:477;;13455:16;13473;13509:72;13529:28;13554:2;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;13529:28;8813:15:6;13509:72:21;;13568:6;13576:4;13509:19;:72::i;:::-;13454:127;;;;13740:8;13734:4;13727:22;13779:8;13773:4;13766:22;13863:9;13822:39;13816:4;13810;13805:68;13651:236;;12730:1173;;12643:1260;;;:::o;11587:128::-;7336:18:20;7330:4;7323:32;;;11662:7:21;7368:19:20;;;7432:4;7416:21;;;7410:28;11688:20:21;7168:286:20;14:332:24;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;230:66;223:5;219:78;212:5;209:89;199:117;;312:1;309;302:12;543:477;692:2;681:9;674:21;655:4;724:6;718:13;767:6;762:2;751:9;747:18;740:34;826:6;821:2;813:6;809:15;804:2;793:9;789:18;783:50;882:1;877:2;868:6;857:9;853:22;849:31;842:42;1011:2;941:66;936:2;928:6;924:15;920:88;909:9;905:104;901:113;893:121;;;543:477;;;;:::o;1025:196::-;1093:20;;1153:42;1142:54;;1132:65;;1122:93;;1211:1;1208;1201:12;1226:300;1294:6;1302;1355:2;1343:9;1334:7;1330:23;1326:32;1323:52;;;1371:1;1368;1361:12;1323:52;1394:29;1413:9;1394:29;:::i;:::-;1384:39;1492:2;1477:18;;;;1464:32;;-1:-1:-1;;;1226:300:24:o;1713:374::-;1790:6;1798;1806;1859:2;1847:9;1838:7;1834:23;1830:32;1827:52;;;1875:1;1872;1865:12;1827:52;1898:29;1917:9;1898:29;:::i;:::-;1888:39;;1946:38;1980:2;1969:9;1965:18;1946:38;:::i;:::-;1713:374;;1936:48;;-1:-1:-1;;;2053:2:24;2038:18;;;;2025:32;;1713:374::o;2092:186::-;2151:6;2204:2;2192:9;2183:7;2179:23;2175:32;2172:52;;;2220:1;2217;2210:12;2172:52;2243:29;2262:9;2243:29;:::i;2654:260::-;2722:6;2730;2783:2;2771:9;2762:7;2758:23;2754:32;2751:52;;;2799:1;2796;2789:12;2751:52;2822:29;2841:9;2822:29;:::i;:::-;2812:39;;2870:38;2904:2;2893:9;2889:18;2870:38;:::i;:::-;2860:48;;2654:260;;;;;:::o;2919:660::-;2998:6;3006;3014;3067:2;3055:9;3046:7;3042:23;3038:32;3035:52;;;3083:1;3080;3073:12;3035:52;3106:29;3125:9;3106:29;:::i;:::-;3096:39;;3186:2;3175:9;3171:18;3158:32;3213:18;3205:6;3202:30;3199:50;;;3245:1;3242;3235:12;3199:50;3268:22;;3321:4;3313:13;;3309:27;-1:-1:-1;3299:55:24;;3350:1;3347;3340:12;3299:55;3390:2;3377:16;3416:18;3408:6;3405:30;3402:50;;;3448:1;3445;3438:12;3402:50;3493:7;3488:2;3479:6;3475:2;3471:15;3467:24;3464:37;3461:57;;;3514:1;3511;3504:12;3461:57;2919:660;;3545:2;3537:11;;;;;-1:-1:-1;3567:6:24;;-1:-1:-1;;;2919:660:24:o;4288:156::-;4354:20;;4414:4;4403:16;;4393:27;;4383:55;;4434:1;4431;4424:12;4449:733;4551:6;4559;4567;4575;4583;4591;4644:3;4632:9;4623:7;4619:23;4615:33;4612:53;;;4661:1;4658;4651:12;4612:53;4684:29;4703:9;4684:29;:::i;:::-;4674:39;-1:-1:-1;4782:2:24;4767:18;;4754:32;;-1:-1:-1;4883:2:24;4868:18;;4855:32;;-1:-1:-1;4932:36:24;4964:2;4949:18;;4932:36;:::i;:::-;4449:733;;;;-1:-1:-1;4449:733:24;;5041:3;5026:19;;5013:33;;5145:3;5130:19;;;5117:33;;-1:-1:-1;4449:733:24;-1:-1:-1;;4449:733:24:o;5187:226::-;5246:6;5299:2;5287:9;5278:7;5274:23;5270:32;5267:52;;;5315:1;5312;5305:12;5267:52;-1:-1:-1;5360:23:24;;5187:226;-1:-1:-1;5187:226:24:o;5418:808::-;5529:6;5537;5545;5553;5561;5569;5577;5630:3;5618:9;5609:7;5605:23;5601:33;5598:53;;;5647:1;5644;5637:12;5598:53;5670:29;5689:9;5670:29;:::i;:::-;5660:39;;5718:38;5752:2;5741:9;5737:18;5718:38;:::i;:::-;5708:48;-1:-1:-1;5825:2:24;5810:18;;5797:32;;-1:-1:-1;5926:2:24;5911:18;;5898:32;;-1:-1:-1;5975:37:24;6007:3;5992:19;;5975:37;:::i;:::-;5418:808;;;;-1:-1:-1;5418:808:24;;;;5965:47;6085:3;6070:19;;6057:33;;-1:-1:-1;6189:3:24;6174:19;;;6161:33;;5418:808;-1:-1:-1;;5418:808:24:o;6231:279::-;6296:9;;;6317:10;;;6314:190;;;6360:77;6357:1;6350:88;6461:4;6458:1;6451:15;6489:4;6486:1;6479:15","linkReferences":{},"cborAuxdata":{},"immutableReferences":{"2795":[{"start":4271,"length":32},{"start":4499,"length":32}]},"transformations":[{"id":"2795","type":"replace","offset":4271,"reason":"immutable"},{"id":"2795","type":"replace","offset":4499,"reason":"immutable"}],"transformationValues":{"immutables":{"2795":"0x00000000000000000000000018ddf8bf26b35c8d70c7514105930ae766c7c172"}}},"deployment":{"transactionHash":"0x90f8392eda28b70d0a2e086078e0004cd43ba573bd4e447e788fe325d4b2ec2e","blockNumber":"27810137","transactionIndex":"234","deployer":"0x14e0433FBE99a44934983282962A5F0Bf226044D"},"sources":{"contracts/src/tokens/lock/ILock.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\ninterface ILockBase {\n  error LockNotAuthorized();\n\n  /// @notice Emitted when the lock is updated.\n  /// @param account The account that was updated.\n  /// @param enabled Whether the lock is enabled.\n  /// @param expiration The expiration of the lock.\n  event LockUpdated(\n    address indexed account,\n    bool indexed enabled,\n    uint256 expiration\n  );\n}\n\ninterface ILock is ILockBase {\n  /// @notice Enables the lock for the given account.\n  /// @param account The account to enable the lock for.\n  function enableLock(address account) external;\n\n  /// @notice Disables the lock and starts the cooldown for the given account.\n  /// @param account The account to disable the lock for.\n  function disableLock(address account) external;\n\n  /// @notice Returns whether the lock is active for the given account.\n  /// @param account The account to check the lock for.\n  /// @return true if the lock is active\n  function isLockActive(address account) external view returns (bool);\n\n  /// @notice Returns the expiration of the lock for the given account.\n  /// @param account The account to check the lock expiration for.\n  /// @return The expiration timestamp.\n  function lockExpiration(address account) external view returns (uint256);\n\n  /// @notice Sets the default cooldown for the lock.\n  /// @param cooldown The cooldown in seconds.\n  function setLockCooldown(uint256 cooldown) external;\n}\n"},"contracts/src/tokens/lock/LockBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {ILockBase} from \"./ILock.sol\";\n\n// libraries\nimport {CustomRevert} from \"contracts/src/utils/libraries/CustomRevert.sol\";\nimport {LockStorage} from \"./LockStorage.sol\";\n\nabstract contract LockBase is ILockBase {\n  function __LockBase_init(uint256 cooldown) internal {\n    _setDefaultCooldown(cooldown);\n  }\n\n  modifier onlyAllowed() {\n    if (!_canLock()) CustomRevert.revertWith(LockNotAuthorized.selector);\n    _;\n  }\n\n  /// @dev Sets the default cooldown for the lock.\n  function _setDefaultCooldown(uint256 cooldown) internal {\n    LockStorage.layout().defaultCooldown = cooldown;\n  }\n\n  /// @dev Enables the lock for the given account.\n  function _enableLock(address account) internal {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    ds.enabledByAddress[account] = true;\n    ds.expirationByAddress[account] = 0;\n\n    emit LockUpdated(account, true, 0);\n  }\n\n  /// @dev Disables the lock and starts the cooldown for the given account.\n  function _disableLock(address account) internal {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    uint256 expiration = block.timestamp + ds.defaultCooldown;\n    ds.enabledByAddress[account] = false;\n    ds.expirationByAddress[account] = expiration;\n\n    emit LockUpdated(account, false, expiration);\n  }\n\n  /// @dev Returns the lock expiration for the given account.\n  function _lockExpiration(address account) internal view returns (uint256) {\n    return LockStorage.layout().expirationByAddress[account];\n  }\n\n  /// @dev Returns whether the lock is active for the given account.\n  function _isLockActive(address account) internal view returns (bool) {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    if (ds.enabledByAddress[account]) return true;\n\n    return block.timestamp < ds.expirationByAddress[account];\n  }\n\n  /// @dev Returns whether the caller is authorized to lock.\n  function _canLock() internal view virtual returns (bool);\n}\n"},"contracts/src/tokens/lock/LockStorage.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\nlibrary LockStorage {\n  // keccak256(\"river.tokens.lock.storage\")\n  bytes32 internal constant STORAGE_SLOT =\n    0xfd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c1;\n\n  struct Layout {\n    uint256 defaultCooldown;\n    mapping(address => bool) enabledByAddress;\n    mapping(address => uint256) expirationByAddress;\n  }\n\n  function layout() internal pure returns (Layout storage l) {\n    assembly {\n      l.slot := STORAGE_SLOT\n    }\n  }\n}\n"},"contracts/src/tokens/towns/base/IERC7802.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC165} from \"@openzeppelin/contracts/interfaces/IERC165.sol\";\n\n/// @title IERC7802\n/// @notice Defines the interface for crosschain ERC20 transfers.\ninterface IERC7802 is IERC165 {\n  /// @notice Emitted when a crosschain transfer mints tokens.\n  /// @param to       Address of the account tokens are being minted for.\n  /// @param amount   Amount of tokens minted.\n  /// @param sender   Address of the account that finalized the crosschain transfer.\n  event CrosschainMint(\n    address indexed to,\n    uint256 amount,\n    address indexed sender\n  );\n\n  /// @notice Emitted when a crosschain transfer burns tokens.\n  /// @param from     Address of the account tokens are being burned from.\n  /// @param amount   Amount of tokens burned.\n  /// @param sender   Address of the account that initiated the crosschain transfer.\n  event CrosschainBurn(\n    address indexed from,\n    uint256 amount,\n    address indexed sender\n  );\n\n  /// @notice Mint tokens through a crosschain transfer.\n  /// @param _to     Address to mint tokens to.\n  /// @param _amount Amount of tokens to mint.\n  function crosschainMint(address _to, uint256 _amount) external;\n\n  /// @notice Burn tokens through a crosschain transfer.\n  /// @param _from   Address to burn tokens from.\n  /// @param _amount Amount of tokens to burn.\n  function crosschainBurn(address _from, uint256 _amount) external;\n}\n"},"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\n\n/// @title IOptimismMintableERC20\n/// @notice This interface is available on the OptimismMintableERC20 contract.\n///         We declare it as a separate interface so that it can be used in\n///         custom implementations of OptimismMintableERC20.\ninterface IOptimismMintableERC20 is IERC165 {\n  function remoteToken() external view returns (address);\n\n  function bridge() external returns (address);\n\n  function mint(address _to, uint256 _amount) external;\n\n  function burn(address _from, uint256 _amount) external;\n}\n\n/// @custom:legacy\n/// @title ILegacyMintableERC20\n/// @notice This interface was available on the legacy L2StandardERC20 contract.\n///         It remains available on the OptimismMintableERC20 contract for\n///         backwards compatibility.\ninterface ILegacyMintableERC20 is IERC165 {\n  function l1Token() external view returns (address);\n\n  function mint(address _to, uint256 _amount) external;\n\n  function burn(address _from, uint256 _amount) external;\n}\n"},"contracts/src/tokens/towns/base/ISemver.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ISemver\n/// @notice ISemver is a simple contract for ensuring that contracts are\n///         versioned using semantic versioning.\ninterface ISemver {\n  /// @notice Getter for the semantic version of the contract. This is not\n  ///         meant to be used onchain but instead meant to be used by offchain\n  ///         tooling.\n  /// @return Semver contract version as a string.\n  function version() external view returns (string memory);\n}\n"},"contracts/src/tokens/towns/base/Towns.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport {IERC20Permit} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\nimport {IERC6372} from \"@openzeppelin/contracts/interfaces/IERC6372.sol\";\nimport {IVotes} from \"@openzeppelin/contracts/governance/utils/IVotes.sol\";\nimport {IOptimismMintableERC20, ILegacyMintableERC20} from \"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol\";\nimport {ISemver} from \"contracts/src/tokens/towns/base/ISemver.sol\";\nimport {IERC7802} from \"contracts/src/tokens/towns/base/IERC7802.sol\";\n\n// libraries\nimport {CustomRevert} from \"contracts/src/utils/libraries/CustomRevert.sol\";\nimport {TownsLib} from \"./TownsLib.sol\";\n\n// contracts\nimport {IntrospectionBase} from \"@river-build/diamond/src/facets/introspection/IntrospectionBase.sol\";\nimport {Ownable} from \"solady/auth/Ownable.sol\";\nimport {Initializable} from \"solady/utils/Initializable.sol\";\nimport {UUPSUpgradeable} from \"solady/utils/UUPSUpgradeable.sol\";\nimport {ERC20Votes} from \"solady/tokens/ERC20Votes.sol\";\nimport {LockBase} from \"contracts/src/tokens/lock/LockBase.sol\";\n\ncontract Towns is\n  IOptimismMintableERC20,\n  IERC7802,\n  ISemver,\n  IntrospectionBase,\n  LockBase,\n  Initializable,\n  ERC20Votes,\n  UUPSUpgradeable,\n  Ownable\n{\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                          Errors                            */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  error DelegateeSameAsCurrent();\n  error TransferLockEnabled();\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                  Constants & Immutables                    */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice The name of the token\n  string internal constant NAME = \"Towns\";\n\n  /// @notice The symbol of the token\n  string internal constant SYMBOL = \"TOWNS\";\n\n  /// @notice The name hash of the token\n  bytes32 internal constant NAME_HASH = keccak256(bytes(NAME));\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                        Modifiers                           */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice A modifier that only allows the bridge to call\n  modifier onlyL2StandardBridge() {\n    if (msg.sender != TownsLib.L2_STANDARD_BRIDGE) {\n      CustomRevert.revertWith(Unauthorized.selector);\n    }\n    _;\n  }\n\n  /// @notice A modifier that only allows the super chain to call\n  modifier onlyL2SuperChainBridge() {\n    if (msg.sender != TownsLib.SUPERCHAIN_TOKEN_BRIDGE) {\n      CustomRevert.revertWith(Unauthorized.selector);\n    }\n    _;\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                      Initialization                        */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  constructor() {\n    _disableInitializers();\n  }\n\n  function initialize(\n    address _remoteToken,\n    address _owner\n  ) external initializer {\n    // set the owner\n    _initializeOwner(_owner);\n\n    // set the remote token\n    TownsLib.initializeRemoteToken(_remoteToken);\n\n    // initialize the lock\n    __LockBase_init(30 days);\n\n    // add interface\n    _addInterface(type(IERC20).interfaceId);\n    _addInterface(type(IERC20Metadata).interfaceId);\n    _addInterface(type(IERC20Permit).interfaceId);\n    _addInterface(type(IERC6372).interfaceId);\n    _addInterface(type(IERC165).interfaceId);\n    _addInterface(type(IVotes).interfaceId);\n    _addInterface(type(IOptimismMintableERC20).interfaceId);\n    _addInterface(type(ILegacyMintableERC20).interfaceId);\n    _addInterface(type(ISemver).interfaceId);\n    _addInterface(type(IERC7802).interfaceId);\n  }\n\n  /// @notice Semantic version\n  /// @custom:semver 1.0.0-beta.12\n  function version() external view virtual returns (string memory) {\n    return \"1.0.0-beta.12\";\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                        Bridge                              */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @custom:legacy\n  /// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\n  function l1Token() external view returns (address) {\n    return TownsLib.layout().remoteToken;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for the bridge. Use BRIDGE going forward.\n  function l2Bridge() external pure returns (address) {\n    return TownsLib.L2_STANDARD_BRIDGE;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for REMOTE_TOKEN\n  function remoteToken() external view returns (address) {\n    return TownsLib.layout().remoteToken;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for L2_STANDARD_BRIDGE.\n  function bridge() external pure returns (address) {\n    return TownsLib.L2_STANDARD_BRIDGE;\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                      Super Chain                           */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice Allows the SuperchainTokenBridge to mint tokens.\n  /// @param _to     Address to mint tokens to.\n  /// @param _amount Amount of tokens to mint.\n  function crosschainMint(\n    address _to,\n    uint256 _amount\n  ) external onlyL2SuperChainBridge {\n    _mint(_to, _amount);\n    emit CrosschainMint(_to, _amount, msg.sender);\n  }\n\n  /// @notice Allows the SuperchainTokenBridge to burn tokens.\n  /// @param _from   Address to burn tokens from.\n  /// @param _amount Amount of tokens to burn.\n  function crosschainBurn(\n    address _from,\n    uint256 _amount\n  ) external onlyL2SuperChainBridge {\n    _burn(_from, _amount);\n    emit CrosschainBurn(_from, _amount, msg.sender);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                     Introspection                          */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @inheritdoc IERC165\n  function supportsInterface(\n    bytes4 interfaceId\n  ) public view virtual override returns (bool) {\n    return _supportsInterface(interfaceId);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                           Lock                               */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function isLockActive(address account) external view virtual returns (bool) {\n    return _isLockActive(account);\n  }\n\n  function lockExpiration(\n    address account\n  ) external view virtual returns (uint256) {\n    return _lockExpiration(account);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                         Overrides                          */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function name() public pure override returns (string memory) {\n    return NAME;\n  }\n\n  function symbol() public pure override returns (string memory) {\n    return SYMBOL;\n  }\n\n  function decimals() public pure override returns (uint8) {\n    return 18;\n  }\n\n  /// @notice Allows the StandardBridge on this network to mint tokens.\n  /// @param to     Address to mint tokens to.\n  /// @param amount Amount of tokens to mint.\n  function mint(\n    address to,\n    uint256 amount\n  ) external override(IOptimismMintableERC20) onlyL2StandardBridge {\n    _mint(to, amount);\n  }\n\n  /// @notice Allows the StandardBridge on this network to burn tokens.\n  /// @param from     Address to burn tokens from.\n  /// @param amount Amount of tokens to burn.\n  function burn(\n    address from,\n    uint256 amount\n  ) external override(IOptimismMintableERC20) onlyL2StandardBridge {\n    _burn(from, amount);\n  }\n\n  /// @notice Clock used for flagging checkpoints, overridden to implement timestamp based\n  /// checkpoints (and voting).\n  function clock() public view override returns (uint48) {\n    return uint48(block.timestamp);\n  }\n\n  /// @notice Machine-readable description of the clock as specified in EIP-6372.\n  function CLOCK_MODE() public pure override returns (string memory) {\n    return \"mode=timestamp\";\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                     Internal Overrides                     */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function _beforeTokenTransfer(\n    address from,\n    address to,\n    uint256 amount\n  ) internal override {\n    if (from != address(0) && _isLockActive(from)) {\n      // allow transferring at minting time\n      CustomRevert.revertWith(TransferLockEnabled.selector);\n    }\n\n    super._beforeTokenTransfer(from, to, amount);\n  }\n\n  function _delegate(address account, address delegatee) internal override {\n    address currentDelegatee = delegates(account);\n\n    // revert if the delegatee is the same as the current delegatee\n    if (currentDelegatee == delegatee)\n      CustomRevert.revertWith(DelegateeSameAsCurrent.selector);\n\n    // if the delegatee is the zero address, initialize disable lock\n    if (delegatee == address(0)) {\n      _disableLock(account);\n    } else {\n      _enableLock(account);\n    }\n\n    super._delegate(account, delegatee);\n  }\n\n  /// @dev Override the name hash to be a constant value for performance in EIP-712\n  function _constantNameHash() internal pure override returns (bytes32) {\n    return NAME_HASH;\n  }\n\n  /// @dev This allows Permit2 to be used without prior approval.\n  function _givePermit2InfiniteAllowance()\n    internal\n    pure\n    override\n    returns (bool)\n  {\n    return true;\n  }\n\n  /// @dev Override the default lock check to disable it.\n  function _canLock() internal pure override returns (bool) {\n    return false;\n  }\n\n  /// @notice Override the default upgrade check to only allow the owner.\n  function _authorizeUpgrade(\n    address newImplementation\n  ) internal override onlyOwner {}\n}\n"},"contracts/src/tokens/towns/base/TownsLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title TownsLib\nlibrary TownsLib {\n  /// @notice Address of the L2StandardBridge predeploy.\n  address internal constant L2_STANDARD_BRIDGE =\n    0x4200000000000000000000000000000000000010;\n\n  /// @notice Address of the SuperchainTokenBridge predeploy.\n  address internal constant SUPERCHAIN_TOKEN_BRIDGE =\n    0x4200000000000000000000000000000000000028;\n\n  // keccak256(abi.encode(uint256(keccak256(\"towns.tokens.l2.storage\")) - 1)) & ~bytes32(uint256(0xff))\n  bytes32 constant STORAGE_SLOT =\n    0x708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b00;\n\n  struct Layout {\n    address remoteToken;\n  }\n\n  function layout() internal pure returns (Layout storage l) {\n    assembly {\n      l.slot := STORAGE_SLOT\n    }\n  }\n\n  function initializeRemoteToken(address _remoteToken) internal {\n    Layout storage l = layout();\n    l.remoteToken = _remoteToken;\n  }\n}\n"},"contracts/src/utils/libraries/CustomRevert.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Library for reverting with custom errors efficiently\n/// @notice Contains functions for reverting with custom errors with different argument types efficiently\n/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with\n/// `CustomError.selector.revertWith()`\n/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately\nlibrary CustomRevert {\n  /// @dev Reverts with the selector of a custom error in the scratch space\n  function revertWith(bytes4 selector) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      revert(0, 0x04)\n    }\n  }\n\n  /// @dev Reverts with a custom error with a uint256 argument in the scratch space\n  function revertWith(bytes4 selector, uint256 value) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      mstore(0x04, value)\n      revert(0, 0x24)\n    }\n  }\n\n  /// @dev Reverts with a custom error with an address argument in the scratch space\n  function revertWith(bytes4 selector, address addr) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))\n      revert(0, 0x24)\n    }\n  }\n}\n"},"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n */\ninterface IVotes {\n    /**\n     * @dev The signature used has expired.\n     */\n    error VotesExpiredSignature(uint256 expiry);\n\n    /**\n     * @dev Emitted when an account changes their delegate.\n     */\n    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /**\n     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units.\n     */\n    event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes);\n\n    /**\n     * @dev Returns the current amount of votes that `account` has.\n     */\n    function getVotes(address account) external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is\n     * configured to use block numbers, this will return the value at the end of the corresponding block.\n     */\n    function getPastVotes(address account, uint256 timepoint) external view returns (uint256);\n\n    /**\n     * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is\n     * configured to use block numbers, this will return the value at the end of the corresponding block.\n     *\n     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n     * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n     * vote.\n     */\n    function getPastTotalSupply(uint256 timepoint) external view returns (uint256);\n\n    /**\n     * @dev Returns the delegate that `account` has chosen.\n     */\n    function delegates(address account) external view returns (address);\n\n    /**\n     * @dev Delegates votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) external;\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`.\n     */\n    function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;\n}\n"},"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC6372.sol)\n\npragma solidity ^0.8.20;\n\ninterface IERC6372 {\n    /**\n     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).\n     */\n    function clock() external view returns (uint48);\n\n    /**\n     * @dev Description of the clock\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function CLOCK_MODE() external view returns (string memory);\n}\n"},"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\ninterface IIntrospectionBase {\n  error Introspection_AlreadySupported();\n  error Introspection_NotSupported();\n\n  /**\n   * @notice Emitted when an interface is added to the contract via `_addInterface`.\n   */\n  event InterfaceAdded(bytes4 indexed interfaceId);\n\n  /**\n   * @notice Emitted when an interface is removed from the contract via `_removeInterface`.\n   */\n  event InterfaceRemoved(bytes4 indexed interfaceId);\n}\n"},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {IIntrospectionBase} from \"./IIntrospectionBase.sol\";\n\n// libraries\nimport {IntrospectionStorage} from \"./IntrospectionStorage.sol\";\n\nabstract contract IntrospectionBase is IIntrospectionBase {\n  function __IntrospectionBase_init() internal {\n    _addInterface(type(IERC165).interfaceId);\n  }\n\n  function _addInterface(bytes4 interfaceId) internal {\n    if (!_supportsInterface(interfaceId)) {\n      IntrospectionStorage.layout().supportedInterfaces[interfaceId] = true;\n    } else {\n      revert Introspection_AlreadySupported();\n    }\n    emit InterfaceAdded(interfaceId);\n  }\n\n  function _removeInterface(bytes4 interfaceId) internal {\n    if (_supportsInterface(interfaceId)) {\n      IntrospectionStorage.layout().supportedInterfaces[interfaceId] = false;\n    } else {\n      revert Introspection_NotSupported();\n    }\n    emit InterfaceRemoved(interfaceId);\n  }\n\n  function _supportsInterface(bytes4 interfaceId) internal view returns (bool) {\n    return IntrospectionStorage.layout().supportedInterfaces[interfaceId];\n  }\n}\n"},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\nlibrary IntrospectionStorage {\n  // keccak256(abi.encode(uint256(keccak256(\"diamond.facets.introspection.storage\")) - 1)) & ~bytes32(uint256(0xff))\n  bytes32 internal constant STORAGE_SLOT =\n    0x81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00;\n\n  struct Layout {\n    mapping(bytes4 => bool) supportedInterfaces;\n  }\n\n  function layout() internal pure returns (Layout storage ds) {\n    bytes32 slot = STORAGE_SLOT;\n    assembly {\n      ds.slot := slot\n    }\n  }\n}\n"},"node_modules/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"node_modules/solady/src/tokens/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC20 + EIP-2612 implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)\n///\n/// @dev Note:\n/// - The ERC20 standard allows minting and transferring to and from the zero address,\n///   minting and transferring zero tokens, as well as self-approvals.\n///   For performance, this implementation WILL NOT revert for such actions.\n///   Please add any checks with overrides if desired.\n/// - The `permit` function uses the ecrecover precompile (0x1).\n///\n/// If you are overriding:\n/// - NEVER violate the ERC20 invariant:\n///   the total sum of all balances must be equal to `totalSupply()`.\n/// - Check that the overridden function is actually used in the function you want to\n///   change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The total supply has overflowed.\n    error TotalSupplyOverflow();\n\n    /// @dev The allowance has overflowed.\n    error AllowanceOverflow();\n\n    /// @dev The allowance has underflowed.\n    error AllowanceUnderflow();\n\n    /// @dev Insufficient balance.\n    error InsufficientBalance();\n\n    /// @dev Insufficient allowance.\n    error InsufficientAllowance();\n\n    /// @dev The permit is invalid.\n    error InvalidPermit();\n\n    /// @dev The permit has expired.\n    error PermitExpired();\n\n    /// @dev The allowance of Permit2 is fixed at infinity.\n    error Permit2AllowanceIsFixedAtInfinity();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n    uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n    /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n    uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot for the total supply.\n    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;\n\n    /// @dev The balance slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _BALANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let balanceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;\n\n    /// @dev The allowance slot of (`owner`, `spender`) is given by:\n    /// ```\n    ///     mstore(0x20, spender)\n    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let allowanceSlot := keccak256(0x0c, 0x34)\n    /// ```\n    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;\n\n    /// @dev The nonce slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _NONCES_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let nonceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.\n    uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"1\")`.\n    /// If you need to use a different version, override `_versionHash`.\n    bytes32 private constant _DEFAULT_VERSION_HASH =\n        0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;\n\n    /// @dev `keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")`.\n    bytes32 private constant _PERMIT_TYPEHASH =\n        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    /// @dev The canonical Permit2 address.\n    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.\n    /// To enable, override `_givePermit2InfiniteAllowance()`.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ERC20 METADATA                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the name of the token.\n    function name() public view virtual returns (string memory);\n\n    /// @dev Returns the symbol of the token.\n    function symbol() public view virtual returns (string memory);\n\n    /// @dev Returns the decimals places of the token.\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           ERC20                            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of tokens in existence.\n    function totalSupply() public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_TOTAL_SUPPLY_SLOT)\n        }\n    }\n\n    /// @dev Returns the amount of tokens owned by `owner`.\n    function balanceOf(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.\n    function allowance(address owner, address spender)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return type(uint256).max;\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x34))\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n    ///\n    /// Emits a {Approval} event.\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))\n        }\n        return true;\n    }\n\n    /// @dev Transfer `amount` tokens from the caller to `to`.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    ///\n    /// Emits a {Transfer} event.\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(msg.sender, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(msg.sender, to, amount);\n        return true;\n    }\n\n    /// @dev Transfers `amount` tokens from `from` to `to`.\n    ///\n    /// Note: Does not update the allowance if it is the maximum uint256 value.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.\n    ///\n    /// Emits a {Transfer} event.\n    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(from, to, amount);\n        // Code duplication is for zero-cost abstraction if possible.\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                if iszero(eq(caller(), _PERMIT2)) {\n                    // Compute the allowance slot and load its value.\n                    mstore(0x20, caller())\n                    mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                    let allowanceSlot := keccak256(0x0c, 0x34)\n                    let allowance_ := sload(allowanceSlot)\n                    // If the allowance is not the maximum uint256 value.\n                    if not(allowance_) {\n                        // Revert if the amount to be transferred exceeds the allowance.\n                        if gt(amount, allowance_) {\n                            mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                            revert(0x1c, 0x04)\n                        }\n                        // Subtract and store the updated allowance.\n                        sstore(allowanceSlot, sub(allowance_, amount))\n                    }\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                // Compute the allowance slot and load its value.\n                mstore(0x20, caller())\n                mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                let allowanceSlot := keccak256(0x0c, 0x34)\n                let allowance_ := sload(allowanceSlot)\n                // If the allowance is not the maximum uint256 value.\n                if not(allowance_) {\n                    // Revert if the amount to be transferred exceeds the allowance.\n                    if gt(amount, allowance_) {\n                        mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                        revert(0x1c, 0x04)\n                    }\n                    // Subtract and store the updated allowance.\n                    sstore(allowanceSlot, sub(allowance_, amount))\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        }\n        _afterTokenTransfer(from, to, amount);\n        return true;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          EIP-2612                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For more performance, override to return the constant value\n    /// of `keccak256(bytes(name()))` if `name()` will never change.\n    function _constantNameHash() internal view virtual returns (bytes32 result) {}\n\n    /// @dev If you need a different value, override this function.\n    function _versionHash() internal view virtual returns (bytes32 result) {\n        result = _DEFAULT_VERSION_HASH;\n    }\n\n    /// @dev For inheriting contracts to increment the nonce.\n    function _incrementNonce(address owner) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            sstore(nonceSlot, add(1, sload(nonceSlot)))\n        }\n    }\n\n    /// @dev Returns the current nonce for `owner`.\n    /// This value is used to compute the signature for EIP-2612 permit.\n    function nonces(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the nonce slot and load its value.\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,\n    /// authorized by a signed approval by `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && value != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Revert if the block timestamp is greater than `deadline`.\n            if gt(timestamp(), deadline) {\n                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40) // Grab the free memory pointer.\n            // Clean the upper 96 bits.\n            owner := shr(96, shl(96, owner))\n            spender := shr(96, shl(96, spender))\n            // Compute the nonce slot and load its value.\n            mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            let nonceValue := sload(nonceSlot)\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x2e, keccak256(m, 0xa0))\n            // Prepare the struct hash.\n            mstore(m, _PERMIT_TYPEHASH)\n            mstore(add(m, 0x20), owner)\n            mstore(add(m, 0x40), spender)\n            mstore(add(m, 0x60), value)\n            mstore(add(m, 0x80), nonceValue)\n            mstore(add(m, 0xa0), deadline)\n            mstore(0x4e, keccak256(m, 0xc0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x2c, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)\n            // If the ecrecover fails, the returndatasize will be 0x00,\n            // `owner` will be checked if it equals the hash at 0x00,\n            // which evaluates to false (i.e. 0), and we will revert.\n            // If the ecrecover succeeds, the returndatasize will be 0x20,\n            // `owner` will be compared against the returned address at 0x20.\n            if iszero(eq(mload(returndatasize()), owner)) {\n                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.\n                revert(0x1c, 0x04)\n            }\n            // Increment and store the updated nonce.\n            sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.\n            // Compute the allowance slot and store the value.\n            // The `owner` is already at slot 0x20.\n            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))\n            sstore(keccak256(0x2c, 0x34), value)\n            // Emit the {Approval} event.\n            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n        }\n    }\n\n    /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Grab the free memory pointer.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            result := keccak256(m, 0xa0)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL MINT FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Mints `amount` tokens to `to`, increasing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _mint(address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(address(0), to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)\n            let totalSupplyAfter := add(totalSupplyBefore, amount)\n            // Revert if the total supply overflows.\n            if lt(totalSupplyAfter, totalSupplyBefore) {\n                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            // Store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(address(0), to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL BURN FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Burns `amount` tokens from `from`, reducing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _burn(address from, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, address(0), amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, from)\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Subtract and store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))\n            // Emit the {Transfer} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)\n        }\n        _afterTokenTransfer(from, address(0), amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL TRANSFER FUNCTIONS                 */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Moves `amount` of tokens from `from` to `to`.\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let from_ := shl(96, from)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL ALLOWANCE FUNCTIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return; // Do nothing, as allowance is infinite.\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and load its value.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            let allowanceSlot := keccak256(0x0c, 0x34)\n            let allowance_ := sload(allowanceSlot)\n            // If the allowance is not the maximum uint256 value.\n            if not(allowance_) {\n                // Revert if the amount to be transferred exceeds the allowance.\n                if gt(amount, allowance_) {\n                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated allowance.\n                sstore(allowanceSlot, sub(allowance_, amount))\n            }\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            let owner_ := shl(96, owner)\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     HOOKS TO OVERRIDE                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Hook that is called before any transfer of tokens.\n    /// This includes minting and burning.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /// @dev Hook that is called after any transfer of tokens.\n    /// This includes minting and burning.\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          PERMIT2                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns whether to fix the Permit2 contract's allowance at infinity.\n    ///\n    /// This value should be kept constant after contract initialization,\n    /// or else the actual allowance values may not match with the {Approval} events.\n    /// For best performance, return a compile-time constant for zero-cost abstraction.\n    function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {\n        return true;\n    }\n}\n"},"node_modules/solady/src/tokens/ERC20Votes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"./ERC20.sol\";\n\n/// @notice ERC20 with votes based on ERC5805 and ERC6372.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20Votes.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Votes.sol)\nabstract contract ERC20Votes is ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The timepoint is in the future.\n    error ERC5805FutureLookup();\n\n    /// @dev The ERC5805 signature to set a delegate has expired.\n    error ERC5805DelegateSignatureExpired();\n\n    /// @dev The ERC5805 signature to set a delegate is invalid.\n    error ERC5805DelegateInvalidSignature();\n\n    /// @dev Out-of-bounds access for the checkpoints.\n    error ERC5805CheckpointIndexOutOfBounds();\n\n    /// @dev Arithmetic overflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueOverflow();\n\n    /// @dev Arithmetic underflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueUnderflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The delegate of `delegator` is changed from `from` to `to`.\n    event DelegateChanged(address indexed delegator, address indexed from, address indexed to);\n\n    /// @dev The votes balance of `delegate` is changed from `oldValue` to `newValue`.\n    event DelegateVotesChanged(address indexed delegate, uint256 oldValue, uint256 newValue);\n\n    /// @dev `keccak256(bytes(\"DelegateChanged(address,address,address)\"))`.\n    uint256 private constant _DELEGATE_CHANGED_EVENT_SIGNATURE =\n        0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f;\n\n    /// @dev `keccak256(bytes(\"DelegateVotesChanged(address,uint256,uint256)\"))`.\n    uint256 private constant _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE =\n        0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\")`.\n    bytes32 private constant _ERC5805_DELEGATION_TYPEHASH =\n        0xe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, account)\n    ///     let delegateSlot := keccak256(0x0c, 0x18)\n    /// ```\n    /// The checkpoints length slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, delegate)\n    ///     let lengthSlot := keccak256(0x0c, 0x17)\n    ///     let length := and(0xffffffffffff, shr(48, sload(lengthSlot)))\n    /// ```\n    /// The total checkpoints length slot is `_ERC20_VOTES_MASTER_SLOT_SEED << 96`.\n    ///\n    /// The `i`-th checkpoint slot is given by:\n    /// ```\n    ///     let checkpointSlot := add(i, lengthSlot)\n    ///     let key := and(sload(checkpointSlot), 0xffffffffffff)\n    ///     let value := shr(96, sload(checkpointSlot))\n    ///     if eq(value, address()) { value := sload(not(checkpointSlot)) }\n    /// ```\n    uint256 private constant _ERC20_VOTES_MASTER_SLOT_SEED = 0xff466c9f;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC6372                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the clock mode.\n    function CLOCK_MODE() public view virtual returns (string memory) {\n        return \"mode=blocknumber&from=default\";\n    }\n\n    /// @dev Returns the current clock.\n    function clock() public view virtual returns (uint48 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := number()\n            // Branch-less out-of-gas revert if `block.number >= 2 ** 48`.\n            returndatacopy(returndatasize(), returndatasize(), sub(0, shr(48, number())))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC5805                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the latest amount of voting units for `account`.\n    function getVotes(address account) public view virtual returns (uint256) {\n        return _checkpointLatest(_delegateCheckpointsSlot(account));\n    }\n\n    /// @dev Returns the latest amount of voting units `account` has before or during `timepoint`.\n    function getPastVotes(address account, uint256 timepoint)\n        public\n        view\n        virtual\n        returns (uint256)\n    {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_delegateCheckpointsSlot(account), timepoint);\n    }\n\n    /// @dev Returns the current voting delegate of `delegator`.\n    function delegates(address delegator) public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, delegator)\n            result := sload(keccak256(0x0c, 0x18))\n        }\n    }\n\n    /// @dev Set the voting delegate of the caller to `delegatee`.\n    function delegate(address delegatee) public virtual {\n        _delegate(msg.sender, delegatee);\n    }\n\n    /// @dev Sets the voting delegate of the signature signer to `delegatee`.\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        address signer;\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if gt(timestamp(), expiry) {\n                mstore(0x00, 0x3480e9e1) // `ERC5805DelegateSignatureExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40)\n            // Prepare the struct hash.\n            mstore(0x00, _ERC5805_DELEGATION_TYPEHASH)\n            mstore(0x20, shr(96, shl(96, delegatee)))\n            mstore(0x40, nonce)\n            mstore(0x60, expiry)\n            mstore(0x40, keccak256(0x00, 0x80))\n            mstore(0x00, 0x1901) // Store \"\\x19\\x01\".\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x20, keccak256(m, 0xa0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x1e, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            signer := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n            // `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.\n            expiry := iszero(returndatasize()) // Reuse `expiry` to denote `ecrecover` failure.\n        }\n        if ((nonces(signer) ^ nonce) | expiry != 0) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                mstore(0x00, 0x1838d95c) // `ERC5805DelegateInvalidSignature()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _incrementNonce(signer);\n        _delegate(signer, delegatee);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              OTHER VOTE PUBLIC VIEW FUNCTIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the number of checkpoints for `account`.\n    function checkpointCount(address account) public view virtual returns (uint256 result) {\n        result = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(result)))\n        }\n    }\n\n    /// @dev Returns the voting checkpoint for `account` at index `i`.\n    function checkpointAt(address account, uint256 i)\n        public\n        view\n        virtual\n        returns (uint48 checkpointClock, uint256 checkpointValue)\n    {\n        uint256 lengthSlot = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(lt(i, shr(208, shl(160, sload(lengthSlot))))) {\n                mstore(0x00, 0x86df9d10) // `ERC5805CheckpointIndexOutOfBounds()`.\n                revert(0x1c, 0x04)\n            }\n            let checkpointPacked := sload(add(i, lengthSlot))\n            checkpointClock := and(0xffffffffffff, checkpointPacked)\n            checkpointValue := shr(96, checkpointPacked)\n            if eq(checkpointValue, address()) { checkpointValue := sload(not(add(i, lengthSlot))) }\n        }\n    }\n\n    /// @dev Returns the latest amount of total voting units.\n    function getVotesTotalSupply() public view virtual returns (uint256) {\n        return _checkpointLatest(_ERC20_VOTES_MASTER_SLOT_SEED << 96);\n    }\n\n    /// @dev Returns the latest amount of total voting units before or during `timepoint`.\n    function getPastVotesTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_ERC20_VOTES_MASTER_SLOT_SEED << 96, timepoint);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of voting units `delegator` has control over.\n    /// Override if you need a different formula.\n    function _getVotingUnits(address delegator) internal view virtual returns (uint256) {\n        return balanceOf(delegator);\n    }\n\n    /// @dev ERC20 after token transfer internal hook.\n    function _afterTokenTransfer(address from, address to, uint256 amount)\n        internal\n        virtual\n        override\n    {\n        _transferVotingUnits(from, to, amount);\n    }\n\n    /// @dev Used in `_afterTokenTransfer(address from, address to, uint256 amount)`.\n    function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\n        if (from == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, true);\n        }\n        if (to == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, false);\n        }\n        _moveDelegateVotes(delegates(from), delegates(to), amount);\n    }\n\n    /// @dev Transfer `amount` of delegated votes from `from` to `to`.\n    /// Emits a {DelegateVotesChanged} event for each change of delegated votes.\n    function _moveDelegateVotes(address from, address to, uint256 amount) internal virtual {\n        if (amount == uint256(0)) return;\n        (uint256 fromCleaned, uint256 toCleaned) = (uint256(uint160(from)), uint256(uint160(to)));\n        if (fromCleaned == toCleaned) return;\n        if (fromCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(from), clock(), amount, false);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, fromCleaned)\n            }\n        }\n        if (toCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(to), clock(), amount, true);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, toCleaned)\n            }\n        }\n    }\n\n    /// @dev Delegates all of `account`'s voting units to `delegatee`.\n    /// Emits the {DelegateChanged} and {DelegateVotesChanged} events.\n    function _delegate(address account, address delegatee) internal virtual {\n        address from;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let to := shr(96, shl(96, delegatee))\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            let delegateSlot := keccak256(0x0c, 0x18)\n            from := sload(delegateSlot)\n            sstore(delegateSlot, to)\n            // Emit the {DelegateChanged} event.\n            log4(0x00, 0x00, _DELEGATE_CHANGED_EVENT_SIGNATURE, shr(96, mload(0x0c)), from, to)\n        }\n        _moveDelegateVotes(from, delegatee, _getVotingUnits(account));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the delegate checkpoints slot for `account`.\n    function _delegateCheckpointsSlot(address account) private pure returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            result := keccak256(0x0c, 0x17)\n        }\n    }\n\n    /// @dev Pushes a checkpoint.\n    function _checkpointPushDiff(uint256 lengthSlot, uint256 key, uint256 amount, bool isAdd)\n        private\n        returns (uint256 oldValue, uint256 newValue)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let lengthSlotPacked := sload(lengthSlot)\n            for { let n := shr(208, shl(160, lengthSlotPacked)) } 1 {} {\n                if iszero(n) {\n                    if iszero(or(isAdd, iszero(amount))) {\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := amount\n                    if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                        sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, newValue)))\n                        break\n                    }\n                    sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, address())))\n                    sstore(not(lengthSlot), newValue)\n                    break\n                }\n                let checkpointSlot := add(sub(n, 1), lengthSlot)\n                let lastPacked := sload(checkpointSlot)\n                oldValue := shr(96, lastPacked)\n                if eq(oldValue, address()) { oldValue := sload(not(checkpointSlot)) }\n                for {} 1 {} {\n                    if iszero(isAdd) {\n                        newValue := sub(oldValue, amount)\n                        if iszero(gt(newValue, oldValue)) { break }\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := add(oldValue, amount)\n                    if iszero(lt(newValue, oldValue)) { break }\n                    mstore(0x00, 0x9dbbeb75) // `ERC5805CheckpointValueOverflow()`.\n                    revert(0x1c, 0x04)\n                }\n                let lastKey := and(0xffffffffffff, lastPacked)\n                if iszero(eq(lastKey, key)) {\n                    n := add(1, n)\n                    checkpointSlot := add(1, checkpointSlot)\n                    sstore(lengthSlot, add(shl(48, 1), lengthSlotPacked))\n                }\n                if or(gt(lastKey, key), shr(48, n)) { invalid() }\n                if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                    sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, newValue)))\n                    break\n                }\n                sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, address())))\n                sstore(not(checkpointSlot), newValue)\n                break\n            }\n        }\n    }\n\n    /// @dev Returns the latest value in the checkpoints.\n    function _checkpointLatest(uint256 lengthSlot) private view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(lengthSlot)))\n            if result {\n                lengthSlot := add(sub(result, 1), lengthSlot) // Reuse for `checkpointSlot`.\n                result := shr(96, sload(lengthSlot))\n                if eq(result, address()) { result := sload(not(lengthSlot)) }\n            }\n        }\n    }\n\n    /// @dev Returns checkpoint value with the largest key that is less than or equal to `key`.\n    function _checkpointUpperLookupRecent(uint256 lengthSlot, uint256 key)\n        private\n        view\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let l := 0 // Low.\n            let h := shr(208, shl(160, sload(lengthSlot))) // High.\n            // Start the binary search nearer to the right to optimize for recent checkpoints.\n            for {} iszero(lt(h, 6)) {} {\n                let m := shl(4, lt(0xffff, h))\n                m := shl(shr(1, or(m, shl(3, lt(0xff, shr(m, h))))), 16)\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := sub(h, shr(1, add(m, div(h, m)))) // Approx `h - sqrt(h)`.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    break\n                }\n                h := m\n                break\n            }\n            // Binary search.\n            for {} lt(l, h) {} {\n                let m := shr(1, add(l, h)) // Won't overflow in practice.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    continue\n                }\n                h := m\n            }\n            let checkpointSlot := add(sub(h, 1), lengthSlot)\n            result := mul(iszero(iszero(h)), shr(96, sload(checkpointSlot)))\n            if eq(result, address()) { result := sload(not(checkpointSlot)) }\n        }\n    }\n\n    /// @dev Reverts with `ERC5805FutureLookup()`.\n    function _revertERC5805FutureLookup() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xf9874464) // `ERC5805FutureLookup()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n"},"node_modules/solady/src/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Initializable mixin for the upgradeable contracts.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Initializable.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy/utils/Initializable.sol)\nabstract contract Initializable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The contract is already initialized.\n    error InvalidInitialization();\n\n    /// @dev The contract is not initializing.\n    error NotInitializing();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Triggered when the contract has been initialized.\n    event Initialized(uint64 version);\n\n    /// @dev `keccak256(bytes(\"Initialized(uint64)\"))`.\n    bytes32 private constant _INTIALIZED_EVENT_SIGNATURE =\n        0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The default initializable slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_INITIALIZABLE_SLOT\")))))`.\n    ///\n    /// Bits Layout:\n    /// - [0]     `initializing`\n    /// - [1..64] `initializedVersion`\n    bytes32 private constant _INITIALIZABLE_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf601132;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                        CONSTRUCTOR                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    constructor() {\n        // Construction time check to ensure that `_initializableSlot()` is not\n        // overridden to zero. Will be optimized away if there is no revert.\n        require(_initializableSlot() != bytes32(0));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a non-zero custom storage slot if required.\n    function _initializableSlot() internal pure virtual returns (bytes32) {\n        return _INITIALIZABLE_SLOT;\n    }\n\n    /// @dev Guards an initializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `initializer`.\n    ///\n    /// This is similar to `reinitializer(1)`, except that in the context of a constructor,\n    /// an `initializer` guarded function can be invoked multiple times.\n    /// This can be useful during testing and is not expected to be used in production.\n    ///\n    /// Emits an {Initialized} event.\n    modifier initializer() virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            // Set `initializing` to 1, `initializedVersion` to 1.\n            sstore(s, 3)\n            // If `!(initializing == 0 && initializedVersion == 0)`.\n            if i {\n                // If `!(address(this).code.length == 0 && initializedVersion == 1)`.\n                if iszero(lt(extcodesize(address()), eq(shr(1, i), 1))) {\n                    mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                    revert(0x1c, 0x04)\n                }\n                s := shl(shl(255, i), s) // Skip initializing if `initializing == 1`.\n            }\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if s {\n                // Set `initializing` to 0, `initializedVersion` to 1.\n                sstore(s, 2)\n                // Emit the {Initialized} event.\n                mstore(0x20, 1)\n                log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards an reinitialzer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `reinitializer`.\n    ///\n    /// Emits an {Initialized} event.\n    modifier reinitializer(uint64 version) virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Clean upper bits, and shift left by 1 to make space for the initializing bit.\n            version := shl(1, and(version, 0xffffffffffffffff))\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(i, version))) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            // Set `initializing` to 1, `initializedVersion` to `version`.\n            sstore(s, or(1, version))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, version)\n            // Emit the {Initialized} event.\n            mstore(0x20, shr(1, version))\n            log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n        }\n    }\n\n    /// @dev Guards a function such that it can only be called in the scope\n    /// of a function guarded with `initializer` or `reinitializer`.\n    modifier onlyInitializing() virtual {\n        _checkInitializing();\n        _;\n    }\n\n    /// @dev Reverts if the contract is not initializing.\n    function _checkInitializing() internal view virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(and(1, sload(s))) {\n                mstore(0x00, 0xd7e6bcf8) // `NotInitializing()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Locks any future initializations by setting the initialized version to `2**64 - 1`.\n    ///\n    /// Calling this in the constructor will prevent the contract from being initialized\n    /// or reinitialized. It is recommended to use this to lock implementation contracts\n    /// that are designed to be called through proxies.\n    ///\n    /// Emits an {Initialized} event the first time it is successfully called.\n    function _disableInitializers() internal virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            if and(i, 1) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            let uint64max := 0xffffffffffffffff\n            if iszero(eq(shr(1, i), uint64max)) {\n                // Set `initializing` to 0, `initializedVersion` to `2**64 - 1`.\n                sstore(s, shl(1, uint64max))\n                // Emit the {Initialized} event.\n                mstore(0x20, uint64max)\n                log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Returns the highest version that has been initialized.\n    function _getInitializedVersion() internal view virtual returns (uint64 version) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            version := shr(1, sload(s))\n        }\n    }\n\n    /// @dev Returns whether the contract is currently initializing.\n    function _isInitializing() internal view virtual returns (bool result) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := and(1, sload(s))\n        }\n    }\n}\n"},"node_modules/solady/src/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice UUPS proxy mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/UUPSUpgradeable.sol)\n/// @author Modified from OpenZeppelin\n/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/utils/UUPSUpgradeable.sol)\n///\n/// @dev Note:\n/// - This implementation is intended to be used with ERC1967 proxies.\n/// See: `LibClone.deployERC1967` and related functions.\n/// - This implementation is NOT compatible with legacy OpenZeppelin proxies\n/// which do not store the implementation at `_ERC1967_IMPLEMENTATION_SLOT`.\nabstract contract UUPSUpgradeable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The upgrade failed.\n    error UpgradeFailed();\n\n    /// @dev The call is from an unauthorized call context.\n    error UnauthorizedCallContext();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         IMMUTABLES                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For checking if the context is a delegate call.\n    uint256 private immutable __self = uint256(uint160(address(this)));\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when the proxy's implementation is upgraded.\n    event Upgraded(address indexed implementation);\n\n    /// @dev `keccak256(bytes(\"Upgraded(address)\"))`.\n    uint256 private constant _UPGRADED_EVENT_SIGNATURE =\n        0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ERC-1967 storage slot for the implementation in the proxy.\n    /// `uint256(keccak256(\"eip1967.proxy.implementation\")) - 1`.\n    bytes32 internal constant _ERC1967_IMPLEMENTATION_SLOT =\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      UUPS OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Please override this function to check if `msg.sender` is authorized\n    /// to upgrade the proxy to `newImplementation`, reverting if not.\n    /// ```\n    ///     function _authorizeUpgrade(address) internal override onlyOwner {}\n    /// ```\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /// @dev Returns the storage slot used by the implementation,\n    /// as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822).\n    ///\n    /// Note: The `notDelegated` modifier prevents accidental upgrades to\n    /// an implementation that is a proxy contract.\n    function proxiableUUID() public view virtual notDelegated returns (bytes32) {\n        // This function must always return `_ERC1967_IMPLEMENTATION_SLOT` to comply with ERC1967.\n        return _ERC1967_IMPLEMENTATION_SLOT;\n    }\n\n    /// @dev Upgrades the proxy's implementation to `newImplementation`.\n    /// Emits a {Upgraded} event.\n    ///\n    /// Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\n    function upgradeToAndCall(address newImplementation, bytes calldata data)\n        public\n        payable\n        virtual\n        onlyProxy\n    {\n        _authorizeUpgrade(newImplementation);\n        /// @solidity memory-safe-assembly\n        assembly {\n            newImplementation := shr(96, shl(96, newImplementation)) // Clears upper 96 bits.\n            mstore(0x00, returndatasize())\n            mstore(0x01, 0x52d1902d) // `proxiableUUID()`.\n            let s := _ERC1967_IMPLEMENTATION_SLOT\n            // Check if `newImplementation` implements `proxiableUUID` correctly.\n            if iszero(eq(mload(staticcall(gas(), newImplementation, 0x1d, 0x04, 0x01, 0x20)), s)) {\n                mstore(0x01, 0x55299b49) // `UpgradeFailed()`.\n                revert(0x1d, 0x04)\n            }\n            // Emit the {Upgraded} event.\n            log2(codesize(), 0x00, _UPGRADED_EVENT_SIGNATURE, newImplementation)\n            sstore(s, newImplementation) // Updates the implementation.\n\n            // Perform a delegatecall to `newImplementation` if `data` is non-empty.\n            if data.length {\n                // Forwards the `data` to `newImplementation` via delegatecall.\n                let m := mload(0x40)\n                calldatacopy(m, data.offset, data.length)\n                if iszero(delegatecall(gas(), newImplementation, m, data.length, codesize(), 0x00))\n                {\n                    // Bubble up the revert if the call reverts.\n                    returndatacopy(m, 0x00, returndatasize())\n                    revert(m, returndatasize())\n                }\n            }\n        }\n    }\n\n    /// @dev Requires that the execution is performed through a proxy.\n    modifier onlyProxy() {\n        uint256 s = __self;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // To enable use cases with an immutable default implementation in the bytecode,\n            // (see: ERC6551Proxy), we don't require that the proxy address must match the\n            // value stored in the implementation slot, which may not be initialized.\n            if eq(s, address()) {\n                mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _;\n    }\n\n    /// @dev Requires that the execution is NOT performed via delegatecall.\n    /// This is the opposite of `onlyProxy`.\n    modifier notDelegated() {\n        uint256 s = __self;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(eq(s, address())) {\n                mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _;\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.29+commit.ab55807c","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":4294967295,"enabled":true},"evmVersion":"cancun","remappings":["@openzeppelin/=node_modules/@openzeppelin/","account-abstraction/=node_modules/account-abstraction/contracts/","ds-test/=node_modules/ds-test/src/","forge-std/=node_modules/forge-std/src/","@prb/math/=node_modules/@prb/math/src/","@prb/test/=node_modules/@prb/test/src/","solady/=node_modules/solady/src/","@river-build/diamond/=node_modules/@river-build/diamond/","crypto-lib/=node_modules/crypto-lib/src/","@solidity/=node_modules/crypto-lib/src/","hardhat-deploy/=node_modules/hardhat-deploy/"]},"name":"Towns","fullyQualifiedName":"contracts/src/tokens/towns/base/Towns.sol:Towns"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AllowanceOverflow","type":"error","inputs":[]},{"name":"AllowanceUnderflow","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"DelegateeSameAsCurrent","type":"error","inputs":[]},{"name":"ERC5805CheckpointIndexOutOfBounds","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueOverflow","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueUnderflow","type":"error","inputs":[]},{"name":"ERC5805DelegateInvalidSignature","type":"error","inputs":[]},{"name":"ERC5805DelegateSignatureExpired","type":"error","inputs":[]},{"name":"ERC5805FutureLookup","type":"error","inputs":[]},{"name":"InsufficientAllowance","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[]},{"name":"Introspection_AlreadySupported","type":"error","inputs":[]},{"name":"Introspection_NotSupported","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidPermit","type":"error","inputs":[]},{"name":"LockNotAuthorized","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"Permit2AllowanceIsFixedAtInfinity","type":"error","inputs":[]},{"name":"PermitExpired","type":"error","inputs":[]},{"name":"TotalSupplyOverflow","type":"error","inputs":[]},{"name":"TransferLockEnabled","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnauthorizedCallContext","type":"error","inputs":[]},{"name":"UpgradeFailed","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CrosschainBurn","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"CrosschainMint","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateChanged","type":"event","inputs":[{"name":"delegator","type":"address","indexed":true,"internalType":"address"},{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateVotesChanged","type":"event","inputs":[{"name":"delegate","type":"address","indexed":true,"internalType":"address"},{"name":"oldValue","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newValue","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"InterfaceAdded","type":"event","inputs":[{"name":"interfaceId","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"InterfaceRemoved","type":"event","inputs":[{"name":"interfaceId","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"LockUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"enabled","type":"bool","indexed":true,"internalType":"bool"},{"name":"expiration","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"CLOCK_MODE","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"result","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"pure"},{"name":"burn","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"checkpointAt","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"i","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"checkpointClock","type":"uint48","internalType":"uint48"},{"name":"checkpointValue","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"checkpointCount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"clock","type":"function","inputs":[],"outputs":[{"name":"","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"crosschainBurn","type":"function","inputs":[{"name":"_from","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"crosschainMint","type":"function","inputs":[{"name":"_to","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"delegate","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegateBySig","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"expiry","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegates","type":"function","inputs":[{"name":"delegator","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getPastVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getPastVotesTotalSupply","type":"function","inputs":[{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotesTotalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_remoteToken","type":"address","internalType":"address"},{"name":"_owner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isLockActive","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"l1Token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"l2Bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"pure"},{"name":"lockExpiration","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"remoteToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.29+commit.ab55807c"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllowanceOverflow","type":"error"},{"inputs":[],"name":"AllowanceUnderflow","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"DelegateeSameAsCurrent","type":"error"},{"inputs":[],"name":"ERC5805CheckpointIndexOutOfBounds","type":"error"},{"inputs":[],"name":"ERC5805CheckpointValueOverflow","type":"error"},{"inputs":[],"name":"ERC5805CheckpointValueUnderflow","type":"error"},{"inputs":[],"name":"ERC5805DelegateInvalidSignature","type":"error"},{"inputs":[],"name":"ERC5805DelegateSignatureExpired","type":"error"},{"inputs":[],"name":"ERC5805FutureLookup","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"Introspection_AlreadySupported","type":"error"},{"inputs":[],"name":"Introspection_NotSupported","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidPermit","type":"error"},{"inputs":[],"name":"LockNotAuthorized","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"Permit2AllowanceIsFixedAtInfinity","type":"error"},{"inputs":[],"name":"PermitExpired","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"TransferLockEnabled","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"UnauthorizedCallContext","type":"error"},{"inputs":[],"name":"UpgradeFailed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"CrosschainBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"CrosschainMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"InterfaceAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"InterfaceRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"bool","name":"enabled","type":"bool"},{"indexed":false,"internalType":"uint256","name":"expiration","type":"uint256"}],"name":"LockUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"CLOCK_MODE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"result","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"i","type":"uint256"}],"name":"checkpointAt","outputs":[{"internalType":"uint48","name":"checkpointClock","type":"uint48"},{"internalType":"uint256","name":"checkpointValue","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"checkpointCount","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clock","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"crosschainBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"crosschainMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"expiry","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"delegateBySig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegator","type":"address"}],"name":"delegates","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"timepoint","type":"uint256"}],"name":"getPastVotesTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVotesTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_remoteToken","type":"address"},{"internalType":"address","name":"_owner","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isLockActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1Token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2Bridge","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"lockExpiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"remoteToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}],"devdoc":{"errors":{"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}],"PermitExpired()":[{"details":"The permit has expired."}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"UpgradeFailed()":[{"details":"The upgrade failed."}]},"events":{"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"CrosschainBurn(address,uint256,address)":{"params":{"amount":"Amount of tokens burned.","from":"Address of the account tokens are being burned from.","sender":"Address of the account that initiated the crosschain transfer."}},"CrosschainMint(address,uint256,address)":{"params":{"amount":"Amount of tokens minted.","sender":"Address of the account that finalized the crosschain transfer.","to":"Address of the account tokens are being minted for."}},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"LockUpdated(address,bool,uint256)":{"params":{"account":"The account that was updated.","enabled":"Whether the lock is enabled.","expiration":"The expiration of the lock."}},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."},"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."}},"kind":"dev","methods":{"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"bridge()":{"custom:legacy":"@notice Legacy getter for L2_STANDARD_BRIDGE."},"burn(address,uint256)":{"params":{"amount":"Amount of tokens to burn.","from":"Address to burn tokens from."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"crosschainBurn(address,uint256)":{"params":{"_amount":"Amount of tokens to burn.","_from":"Address to burn tokens from."}},"crosschainMint(address,uint256)":{"params":{"_amount":"Amount of tokens to mint.","_to":"Address to mint tokens to."}},"decimals()":{"details":"Returns the decimals places of the token."},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before or during `timepoint`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before or during `timepoint`."},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"l1Token()":{"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward."},"l2Bridge()":{"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward."},"mint(address,uint256)":{"params":{"amount":"Amount of tokens to mint.","to":"Address to mint tokens to."}},"name()":{"details":"Returns the name of the token."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"owner()":{"details":"Returns the owner of the contract."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"remoteToken()":{"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN"},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"symbol()":{"details":"Returns the symbol of the token."},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."},"version()":{"custom:semver":"1.0.0-beta.12"}},"version":1},"userdoc":{"events":{"CrosschainBurn(address,uint256,address)":{"notice":"Emitted when a crosschain transfer burns tokens."},"CrosschainMint(address,uint256,address)":{"notice":"Emitted when a crosschain transfer mints tokens."},"InterfaceAdded(bytes4)":{"notice":"Emitted when an interface is added to the contract via `_addInterface`."},"InterfaceRemoved(bytes4)":{"notice":"Emitted when an interface is removed from the contract via `_removeInterface`."},"LockUpdated(address,bool,uint256)":{"notice":"Emitted when the lock is updated."}},"kind":"user","methods":{"CLOCK_MODE()":{"notice":"Machine-readable description of the clock as specified in EIP-6372."},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"clock()":{"notice":"Clock used for flagging checkpoints, overridden to implement timestamp based checkpoints (and voting)."},"crosschainBurn(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to burn tokens."},"crosschainMint(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to mint tokens."},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"version()":{"notice":"Semantic version"}},"version":1}},"settings":{"compilationTarget":{"contracts/src/tokens/towns/base/Towns.sol":"Towns"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":4294967295},"remappings":[":@openzeppelin/=node_modules/@openzeppelin/",":@prb/math/=node_modules/@prb/math/src/",":@prb/test/=node_modules/@prb/test/src/",":@river-build/diamond/=node_modules/@river-build/diamond/",":@solidity/=node_modules/crypto-lib/src/",":account-abstraction/=node_modules/account-abstraction/contracts/",":crypto-lib/=node_modules/crypto-lib/src/",":ds-test/=node_modules/ds-test/src/",":forge-std/=node_modules/forge-std/src/",":hardhat-deploy/=node_modules/hardhat-deploy/",":solady/=node_modules/solady/src/"]},"sources":{"contracts/src/tokens/lock/ILock.sol":{"keccak256":"0x1768d1162b79cd091bfa369e057ad1707342ad33855cacb6c823947040673666","license":"MIT","urls":["bzz-raw://8dc8f9747bf7e9656ec929746feb65dd698c36a336ac751461cf89116dd265e2","dweb:/ipfs/QmewowhYAGxqDDvkExMzdYE9DqyWkwDiF7SS9QPGrgUNL4"]},"contracts/src/tokens/lock/LockBase.sol":{"keccak256":"0x4685389037dfc2a3e039ba397be7030c7e82a092971f3051c6778fa84f438591","license":"MIT","urls":["bzz-raw://c043ae8d2f7c262adb63eb124efb7fa05f72ae701bb0fd448d94e7eae9ac3dcf","dweb:/ipfs/QmVL1dCW27P2mfqznvnLmKWcKQVFbMg4xadLe1ubiEMDDG"]},"contracts/src/tokens/lock/LockStorage.sol":{"keccak256":"0x80926f5941dd1137653389eec0cf56d51f3dcfdf84bbcd607b1b8b399459789d","license":"MIT","urls":["bzz-raw://6f88d440958ad5a29b02fdf3ac0cdbc43b8c65344faf87d49a6eef4154614a32","dweb:/ipfs/QmUNpHqwqrhP2aepWU6kVM52osMbBUvWGctXSqyjoND6wc"]},"contracts/src/tokens/towns/base/IERC7802.sol":{"keccak256":"0xa386a790ab0cc57bd6c207fd36d2d8b748ddd576ce0bcf41548c20c2073f5d5c","license":"MIT","urls":["bzz-raw://51cd0d5edbfabc1ed79f65c4983fe91809b9fb198ef7a46c7fb6759c8f1f364c","dweb:/ipfs/QmQVMUfz7p5GeD6FFJm795fxsYtfdbYTMzoYF8Df2eSfHC"]},"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol":{"keccak256":"0x8f1c7a7be76ccbaa51e36a604d97d227786c7e12c6be8764e66d14654225d32d","license":"MIT","urls":["bzz-raw://d94b0c58b10424554715d42ad26c41a654268b73d7df3da196672036f17cbd2a","dweb:/ipfs/QmXaBeEytq2WzdkXvp5cbgoW3KAzvjgYqLxEeSvRHwP664"]},"contracts/src/tokens/towns/base/ISemver.sol":{"keccak256":"0x8debf818a0e7f49313d76b22ed9ff03c459553969bc257887963494e1b1fadf6","license":"MIT","urls":["bzz-raw://f033090fc07df64e15bf62bed3bfb03ded05cd7498793c378b8c6342a9a4c794","dweb:/ipfs/QmRCEdKFeNiepYwuZc3pqwQ2ufSiMZD7rzDwS9Du1pSQHz"]},"contracts/src/tokens/towns/base/Towns.sol":{"keccak256":"0xf13e42c72fe06d701b6b944589b26d4de6e3bb81ec5875a15f59646793e226c2","license":"MIT","urls":["bzz-raw://0641368d7ace22db248623382625711aa5d980a6b9de31ddfe92e3f31e6079eb","dweb:/ipfs/QmaBKi4KtVkdwa3o8REr58ZtHfAbHky77jkbZd8zaBS6c7"]},"contracts/src/tokens/towns/base/TownsLib.sol":{"keccak256":"0x03386e26b96a78f2190696bbc84e80d688b368276b01760f88b72bc1e769dcba","license":"MIT","urls":["bzz-raw://ba73bc41da1a110bb513e97241c6de4858e96935b1e5cfeeacf6eb7865ee3620","dweb:/ipfs/QmUjpd63QCKkBZa5ysbwFiL4msHMo4yZnaVCeM9DBHynHy"]},"contracts/src/utils/libraries/CustomRevert.sol":{"keccak256":"0xdf3d131cb19a367b2f2842caffe356e3b6437ff9e82f6519dd3b067630e0a059","license":"MIT","urls":["bzz-raw://abaae9b8fa22a7b0f6fe0adafb4ec510f9b720ef281d98b900225c033c66f9b7","dweb:/ipfs/QmNU1NRUCkXibWP7PzNyXvtrkgtpwcUEVP8uFzsWeDmBfK"]},"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol":{"keccak256":"0x5e2b397ae88fd5c68e4f6762eb9f65f65c36702eb57796495f471d024ce70947","license":"MIT","urls":["bzz-raw://348fc8e291d54314bb22437b532f443d5dbfb80c8cc9591567c1af6554ccf856","dweb:/ipfs/QmP8ZTyitZinxcpwAHeYHhwj7u21zPpKXSiww38V74sXC2"]},"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol":{"keccak256":"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724","license":"MIT","urls":["bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a","dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS"]},"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol":{"keccak256":"0xeb2857b7dafb7e0d8526dbfe794e6c047df2851c9e6ee91dc4a55f3c34af5d33","license":"MIT","urls":["bzz-raw://49bf13f6c2a38a9bcc7b852d4e2b9cebb4068b832642cce61069cdb5f06bb2fb","dweb:/ipfs/QmdKAJVE7rR2kENCZnEM1yKswrGii7WuE9gZpsQvnXJhwn"]},"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7","license":"MIT","urls":["bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db","dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9"]},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330","license":"MIT","urls":["bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf","dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r"]},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"keccak256":"0x27dbc90e5136ffe46c04f7596fc2dbcc3acebd8d504da3d93fdb8496e6de04f6","license":"MIT","urls":["bzz-raw://0ea8b92e4245d75a5579c10f22f118f7b4ba07c57341f181f0b2a85ff8663de3","dweb:/ipfs/Qme3Ss5ByjmkxxkMdLpyu7fQ1PCtjNFH1wEFszt2BZePiG"]},"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8","license":"MIT","urls":["bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621","dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"]},"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol":{"keccak256":"0x51e706ab1184a3a5b353b87cfee07d471b9a5ef93897022bbcd1085b39a0c762","license":"MIT","urls":["bzz-raw://3df386912c5cc759faee161b7825b2014040d04bf06528e74f4d759f06f2eb19","dweb:/ipfs/QmP5AnGGNY4gsV1ABJ3WaueAsAwJVQ229ZfGjGxW8rSbEL"]},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol":{"keccak256":"0x35f27aa0a4b64673a2648110422f31de0c5a71c68df562eccb9c4f2a27ee6647","license":"MIT","urls":["bzz-raw://2eb1f2ff2e2d7222bf8fe2cf7558a2e47925e3d4557208362b1f50e63cb43006","dweb:/ipfs/QmNcJZSAEPreUy66tt5brPrauVnUb4tqvcxej5Uc4SZZWz"]},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol":{"keccak256":"0x306f41ef86bc5050a28c1dbf855d3f6f623be4aebc0a0f96474dae85979f7763","license":"MIT","urls":["bzz-raw://dbad6f8e6685690ae75f6c9066972a45400b45307245feab8990af18a4c38e91","dweb:/ipfs/QmcTUqiSL1z2nwokpNNsXQkjVTaFdFJiM2exguZpPDDXEM"]},"node_modules/solady/src/auth/Ownable.sol":{"keccak256":"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3","license":"MIT","urls":["bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3","dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs"]},"node_modules/solady/src/tokens/ERC20.sol":{"keccak256":"0x5077e979c44badb9f88c24ef9f7991b47ede9d885aeb348a3dc1d38574a9259d","license":"MIT","urls":["bzz-raw://f8a4dd59c08c087de1799ca29223581943d842f44fdbb9aa80647f5cf230e4a2","dweb:/ipfs/QmXBTFix6cZQtH5kA3smuveJFP1xpv7fjWiqWYN8Ny3roV"]},"node_modules/solady/src/tokens/ERC20Votes.sol":{"keccak256":"0x142c47b1e714831fdb1ff88901b3b3bddf26a568c48997fa285203f18d7b91e4","license":"MIT","urls":["bzz-raw://f4bce951eb0cf10ce1c8e34fd65bdd7b309319f4548c543a0c81afabded7f916","dweb:/ipfs/QmXb7vVpBhNFSuj49srx5oNxJeKEM8mFZgS11Z5Cvvordv"]},"node_modules/solady/src/utils/Initializable.sol":{"keccak256":"0x0873a4cd2510a6f741a3abe8bbb40e6969f45b667431e80247e14ca54f7eb644","license":"MIT","urls":["bzz-raw://e22e60919b1dc56d62e9e7889174edc7b212cef4cf8686a5e207d324e7b8148f","dweb:/ipfs/QmSjDw5EkCCb8JETqn3YoUXYJ7BYJQex1r9p85zjYY99wu"]},"node_modules/solady/src/utils/UUPSUpgradeable.sol":{"keccak256":"0xed1dbffe8abb226c51288d4fbdedb4da90d50617bfae1cbcc093383a4ec0710a","license":"MIT","urls":["bzz-raw://f41d6e515669bd177befad00fb05a0596ae548a7976e8d39799bd5f9f6329d89","dweb:/ipfs/QmXZMccdm5ZGBjuTHdBH7qZRJV89gdY5ogQFQiqACgaWBv"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","events":{"InterfaceAdded(bytes4)":{"notice":"Emitted when an interface is added to the contract via `_addInterface`."},"InterfaceRemoved(bytes4)":{"notice":"Emitted when an interface is removed from the contract via `_removeInterface`."},"LockUpdated(address,bool,uint256)":{"notice":"Emitted when the lock is updated."},"CrosschainBurn(address,uint256,address)":{"notice":"Emitted when a crosschain transfer burns tokens."},"CrosschainMint(address,uint256,address)":{"notice":"Emitted when a crosschain transfer mints tokens."}},"methods":{"clock()":{"notice":"Clock used for flagging checkpoints, overridden to implement timestamp based checkpoints (and voting)."},"version()":{"notice":"Semantic version"},"CLOCK_MODE()":{"notice":"Machine-readable description of the clock as specified in EIP-6372."},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"crosschainBurn(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to burn tokens."},"crosschainMint(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to mint tokens."}},"version":1},"devdoc":{"kind":"dev","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"PermitExpired()":[{"details":"The permit has expired."}],"UpgradeFailed()":[{"details":"The upgrade failed."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}]},"events":{"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"LockUpdated(address,bool,uint256)":{"params":{"account":"The account that was updated.","enabled":"Whether the lock is enabled.","expiration":"The expiration of the lock."}},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"CrosschainBurn(address,uint256,address)":{"params":{"from":"Address of the account tokens are being burned from.","amount":"Amount of tokens burned.","sender":"Address of the account that initiated the crosschain transfer."}},"CrosschainMint(address,uint256,address)":{"params":{"to":"Address of the account tokens are being minted for.","amount":"Amount of tokens minted.","sender":"Address of the account that finalized the crosschain transfer."}},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the owner of the contract."},"bridge()":{"custom:legacy":"@notice Legacy getter for L2_STANDARD_BRIDGE."},"symbol()":{"details":"Returns the symbol of the token."},"l1Token()":{"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward."},"version()":{"custom:semver":"1.0.0-beta.12"},"decimals()":{"details":"Returns the decimals places of the token."},"l2Bridge()":{"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward."},"remoteToken()":{"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN"},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"burn(address,uint256)":{"params":{"from":"Address to burn tokens from.","amount":"Amount of tokens to burn."}},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"mint(address,uint256)":{"params":{"to":"Address to mint tokens to.","amount":"Amount of tokens to mint."}},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before or during `timepoint`."},"crosschainBurn(address,uint256)":{"params":{"_from":"Address to burn tokens from.","_amount":"Amount of tokens to burn."}},"crosschainMint(address,uint256)":{"params":{"_to":"Address to mint tokens to.","_amount":"Amount of tokens to mint."}},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before or during `timepoint`."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."}},"version":1},"sourceIds":{"contracts/src/tokens/lock/ILock.sol":{"id":0},"contracts/src/tokens/lock/LockBase.sol":{"id":1},"node_modules/solady/src/auth/Ownable.sol":{"id":19},"node_modules/solady/src/tokens/ERC20.sol":{"id":20},"contracts/src/tokens/lock/LockStorage.sol":{"id":2},"contracts/src/tokens/towns/base/Towns.sol":{"id":6},"contracts/src/tokens/towns/base/ISemver.sol":{"id":5},"contracts/src/tokens/towns/base/IERC7802.sol":{"id":3},"contracts/src/tokens/towns/base/TownsLib.sol":{"id":7},"node_modules/solady/src/tokens/ERC20Votes.sol":{"id":21},"contracts/src/utils/libraries/CustomRevert.sol":{"id":8},"node_modules/solady/src/utils/Initializable.sol":{"id":22},"node_modules/solady/src/utils/UUPSUpgradeable.sol":{"id":23},"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol":{"id":4},"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol":{"id":10},"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":12},"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol":{"id":11},"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol":{"id":9},"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":15},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":14},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":13},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol":{"id":17},"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol":{"id":16},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol":{"id":18}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/src/tokens/lock/ILock.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\ninterface ILockBase {\n  error LockNotAuthorized();\n\n  /// @notice Emitted when the lock is updated.\n  /// @param account The account that was updated.\n  /// @param enabled Whether the lock is enabled.\n  /// @param expiration The expiration of the lock.\n  event LockUpdated(\n    address indexed account,\n    bool indexed enabled,\n    uint256 expiration\n  );\n}\n\ninterface ILock is ILockBase {\n  /// @notice Enables the lock for the given account.\n  /// @param account The account to enable the lock for.\n  function enableLock(address account) external;\n\n  /// @notice Disables the lock and starts the cooldown for the given account.\n  /// @param account The account to disable the lock for.\n  function disableLock(address account) external;\n\n  /// @notice Returns whether the lock is active for the given account.\n  /// @param account The account to check the lock for.\n  /// @return true if the lock is active\n  function isLockActive(address account) external view returns (bool);\n\n  /// @notice Returns the expiration of the lock for the given account.\n  /// @param account The account to check the lock expiration for.\n  /// @return The expiration timestamp.\n  function lockExpiration(address account) external view returns (uint256);\n\n  /// @notice Sets the default cooldown for the lock.\n  /// @param cooldown The cooldown in seconds.\n  function setLockCooldown(uint256 cooldown) external;\n}\n"},"contracts/src/tokens/lock/LockBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {ILockBase} from \"./ILock.sol\";\n\n// libraries\nimport {CustomRevert} from \"contracts/src/utils/libraries/CustomRevert.sol\";\nimport {LockStorage} from \"./LockStorage.sol\";\n\nabstract contract LockBase is ILockBase {\n  function __LockBase_init(uint256 cooldown) internal {\n    _setDefaultCooldown(cooldown);\n  }\n\n  modifier onlyAllowed() {\n    if (!_canLock()) CustomRevert.revertWith(LockNotAuthorized.selector);\n    _;\n  }\n\n  /// @dev Sets the default cooldown for the lock.\n  function _setDefaultCooldown(uint256 cooldown) internal {\n    LockStorage.layout().defaultCooldown = cooldown;\n  }\n\n  /// @dev Enables the lock for the given account.\n  function _enableLock(address account) internal {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    ds.enabledByAddress[account] = true;\n    ds.expirationByAddress[account] = 0;\n\n    emit LockUpdated(account, true, 0);\n  }\n\n  /// @dev Disables the lock and starts the cooldown for the given account.\n  function _disableLock(address account) internal {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    uint256 expiration = block.timestamp + ds.defaultCooldown;\n    ds.enabledByAddress[account] = false;\n    ds.expirationByAddress[account] = expiration;\n\n    emit LockUpdated(account, false, expiration);\n  }\n\n  /// @dev Returns the lock expiration for the given account.\n  function _lockExpiration(address account) internal view returns (uint256) {\n    return LockStorage.layout().expirationByAddress[account];\n  }\n\n  /// @dev Returns whether the lock is active for the given account.\n  function _isLockActive(address account) internal view returns (bool) {\n    LockStorage.Layout storage ds = LockStorage.layout();\n\n    if (ds.enabledByAddress[account]) return true;\n\n    return block.timestamp < ds.expirationByAddress[account];\n  }\n\n  /// @dev Returns whether the caller is authorized to lock.\n  function _canLock() internal view virtual returns (bool);\n}\n"},"node_modules/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"node_modules/solady/src/tokens/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple ERC20 + EIP-2612 implementation.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)\n///\n/// @dev Note:\n/// - The ERC20 standard allows minting and transferring to and from the zero address,\n///   minting and transferring zero tokens, as well as self-approvals.\n///   For performance, this implementation WILL NOT revert for such actions.\n///   Please add any checks with overrides if desired.\n/// - The `permit` function uses the ecrecover precompile (0x1).\n///\n/// If you are overriding:\n/// - NEVER violate the ERC20 invariant:\n///   the total sum of all balances must be equal to `totalSupply()`.\n/// - Check that the overridden function is actually used in the function you want to\n///   change the behavior of. Much of the code has been manually inlined for performance.\nabstract contract ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The total supply has overflowed.\n    error TotalSupplyOverflow();\n\n    /// @dev The allowance has overflowed.\n    error AllowanceOverflow();\n\n    /// @dev The allowance has underflowed.\n    error AllowanceUnderflow();\n\n    /// @dev Insufficient balance.\n    error InsufficientBalance();\n\n    /// @dev Insufficient allowance.\n    error InsufficientAllowance();\n\n    /// @dev The permit is invalid.\n    error InvalidPermit();\n\n    /// @dev The permit has expired.\n    error PermitExpired();\n\n    /// @dev The allowance of Permit2 is fixed at infinity.\n    error Permit2AllowanceIsFixedAtInfinity();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.\n    event Transfer(address indexed from, address indexed to, uint256 amount);\n\n    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\n    event Approval(address indexed owner, address indexed spender, uint256 amount);\n\n    /// @dev `keccak256(bytes(\"Transfer(address,address,uint256)\"))`.\n    uint256 private constant _TRANSFER_EVENT_SIGNATURE =\n        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;\n\n    /// @dev `keccak256(bytes(\"Approval(address,address,uint256)\"))`.\n    uint256 private constant _APPROVAL_EVENT_SIGNATURE =\n        0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The storage slot for the total supply.\n    uint256 private constant _TOTAL_SUPPLY_SLOT = 0x05345cdf77eb68f44c;\n\n    /// @dev The balance slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _BALANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let balanceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _BALANCE_SLOT_SEED = 0x87a211a2;\n\n    /// @dev The allowance slot of (`owner`, `spender`) is given by:\n    /// ```\n    ///     mstore(0x20, spender)\n    ///     mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let allowanceSlot := keccak256(0x0c, 0x34)\n    /// ```\n    uint256 private constant _ALLOWANCE_SLOT_SEED = 0x7f5e9f20;\n\n    /// @dev The nonce slot of `owner` is given by:\n    /// ```\n    ///     mstore(0x0c, _NONCES_SLOT_SEED)\n    ///     mstore(0x00, owner)\n    ///     let nonceSlot := keccak256(0x0c, 0x20)\n    /// ```\n    uint256 private constant _NONCES_SLOT_SEED = 0x38377508;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `(_NONCES_SLOT_SEED << 16) | 0x1901`.\n    uint256 private constant _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX = 0x383775081901;\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"1\")`.\n    /// If you need to use a different version, override `_versionHash`.\n    bytes32 private constant _DEFAULT_VERSION_HASH =\n        0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6;\n\n    /// @dev `keccak256(\"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)\")`.\n    bytes32 private constant _PERMIT_TYPEHASH =\n        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;\n\n    /// @dev The canonical Permit2 address.\n    /// For signature-based allowance granting for single transaction ERC20 `transferFrom`.\n    /// To enable, override `_givePermit2InfiniteAllowance()`.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ERC20 METADATA                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the name of the token.\n    function name() public view virtual returns (string memory);\n\n    /// @dev Returns the symbol of the token.\n    function symbol() public view virtual returns (string memory);\n\n    /// @dev Returns the decimals places of the token.\n    function decimals() public view virtual returns (uint8) {\n        return 18;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           ERC20                            */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of tokens in existence.\n    function totalSupply() public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_TOTAL_SUPPLY_SLOT)\n        }\n    }\n\n    /// @dev Returns the amount of tokens owned by `owner`.\n    function balanceOf(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.\n    function allowance(address owner, address spender)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return type(uint256).max;\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x34))\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n    ///\n    /// Emits a {Approval} event.\n    function approve(address spender, uint256 amount) public virtual returns (bool) {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, caller(), shr(96, mload(0x2c)))\n        }\n        return true;\n    }\n\n    /// @dev Transfer `amount` tokens from the caller to `to`.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    ///\n    /// Emits a {Transfer} event.\n    function transfer(address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(msg.sender, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, caller())\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, caller(), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(msg.sender, to, amount);\n        return true;\n    }\n\n    /// @dev Transfers `amount` tokens from `from` to `to`.\n    ///\n    /// Note: Does not update the allowance if it is the maximum uint256 value.\n    ///\n    /// Requirements:\n    /// - `from` must at least have `amount`.\n    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.\n    ///\n    /// Emits a {Transfer} event.\n    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {\n        _beforeTokenTransfer(from, to, amount);\n        // Code duplication is for zero-cost abstraction if possible.\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                if iszero(eq(caller(), _PERMIT2)) {\n                    // Compute the allowance slot and load its value.\n                    mstore(0x20, caller())\n                    mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                    let allowanceSlot := keccak256(0x0c, 0x34)\n                    let allowance_ := sload(allowanceSlot)\n                    // If the allowance is not the maximum uint256 value.\n                    if not(allowance_) {\n                        // Revert if the amount to be transferred exceeds the allowance.\n                        if gt(amount, allowance_) {\n                            mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                            revert(0x1c, 0x04)\n                        }\n                        // Subtract and store the updated allowance.\n                        sstore(allowanceSlot, sub(allowance_, amount))\n                    }\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let from_ := shl(96, from)\n                // Compute the allowance slot and load its value.\n                mstore(0x20, caller())\n                mstore(0x0c, or(from_, _ALLOWANCE_SLOT_SEED))\n                let allowanceSlot := keccak256(0x0c, 0x34)\n                let allowance_ := sload(allowanceSlot)\n                // If the allowance is not the maximum uint256 value.\n                if not(allowance_) {\n                    // Revert if the amount to be transferred exceeds the allowance.\n                    if gt(amount, allowance_) {\n                        mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                        revert(0x1c, 0x04)\n                    }\n                    // Subtract and store the updated allowance.\n                    sstore(allowanceSlot, sub(allowance_, amount))\n                }\n                // Compute the balance slot and load its value.\n                mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n                let fromBalanceSlot := keccak256(0x0c, 0x20)\n                let fromBalance := sload(fromBalanceSlot)\n                // Revert if insufficient balance.\n                if gt(amount, fromBalance) {\n                    mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated balance.\n                sstore(fromBalanceSlot, sub(fromBalance, amount))\n                // Compute the balance slot of `to`.\n                mstore(0x00, to)\n                let toBalanceSlot := keccak256(0x0c, 0x20)\n                // Add and store the updated balance of `to`.\n                // Will not overflow because the sum of all user balances\n                // cannot exceed the maximum uint256 value.\n                sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n                // Emit the {Transfer} event.\n                mstore(0x20, amount)\n                log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n            }\n        }\n        _afterTokenTransfer(from, to, amount);\n        return true;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          EIP-2612                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For more performance, override to return the constant value\n    /// of `keccak256(bytes(name()))` if `name()` will never change.\n    function _constantNameHash() internal view virtual returns (bytes32 result) {}\n\n    /// @dev If you need a different value, override this function.\n    function _versionHash() internal view virtual returns (bytes32 result) {\n        result = _DEFAULT_VERSION_HASH;\n    }\n\n    /// @dev For inheriting contracts to increment the nonce.\n    function _incrementNonce(address owner) internal virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            sstore(nonceSlot, add(1, sload(nonceSlot)))\n        }\n    }\n\n    /// @dev Returns the current nonce for `owner`.\n    /// This value is used to compute the signature for EIP-2612 permit.\n    function nonces(address owner) public view virtual returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the nonce slot and load its value.\n            mstore(0x0c, _NONCES_SLOT_SEED)\n            mstore(0x00, owner)\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /// @dev Sets `value` as the allowance of `spender` over the tokens of `owner`,\n    /// authorized by a signed approval by `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && value != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(value)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Revert if the block timestamp is greater than `deadline`.\n            if gt(timestamp(), deadline) {\n                mstore(0x00, 0x1a15a3cc) // `PermitExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40) // Grab the free memory pointer.\n            // Clean the upper 96 bits.\n            owner := shr(96, shl(96, owner))\n            spender := shr(96, shl(96, spender))\n            // Compute the nonce slot and load its value.\n            mstore(0x0e, _NONCES_SLOT_SEED_WITH_SIGNATURE_PREFIX)\n            mstore(0x00, owner)\n            let nonceSlot := keccak256(0x0c, 0x20)\n            let nonceValue := sload(nonceSlot)\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x2e, keccak256(m, 0xa0))\n            // Prepare the struct hash.\n            mstore(m, _PERMIT_TYPEHASH)\n            mstore(add(m, 0x20), owner)\n            mstore(add(m, 0x40), spender)\n            mstore(add(m, 0x60), value)\n            mstore(add(m, 0x80), nonceValue)\n            mstore(add(m, 0xa0), deadline)\n            mstore(0x4e, keccak256(m, 0xc0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x2c, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            let t := staticcall(gas(), 1, 0x00, 0x80, 0x20, 0x20)\n            // If the ecrecover fails, the returndatasize will be 0x00,\n            // `owner` will be checked if it equals the hash at 0x00,\n            // which evaluates to false (i.e. 0), and we will revert.\n            // If the ecrecover succeeds, the returndatasize will be 0x20,\n            // `owner` will be compared against the returned address at 0x20.\n            if iszero(eq(mload(returndatasize()), owner)) {\n                mstore(0x00, 0xddafbaef) // `InvalidPermit()`.\n                revert(0x1c, 0x04)\n            }\n            // Increment and store the updated nonce.\n            sstore(nonceSlot, add(nonceValue, t)) // `t` is 1 if ecrecover succeeds.\n            // Compute the allowance slot and store the value.\n            // The `owner` is already at slot 0x20.\n            mstore(0x40, or(shl(160, _ALLOWANCE_SLOT_SEED), spender))\n            sstore(keccak256(0x2c, 0x34), value)\n            // Emit the {Approval} event.\n            log3(add(m, 0x60), 0x20, _APPROVAL_EVENT_SIGNATURE, owner, spender)\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n        }\n    }\n\n    /// @dev Returns the EIP-712 domain separator for the EIP-2612 permit.\n    function DOMAIN_SEPARATOR() public view virtual returns (bytes32 result) {\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Grab the free memory pointer.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            result := keccak256(m, 0xa0)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL MINT FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Mints `amount` tokens to `to`, increasing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _mint(address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(address(0), to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let totalSupplyBefore := sload(_TOTAL_SUPPLY_SLOT)\n            let totalSupplyAfter := add(totalSupplyBefore, amount)\n            // Revert if the total supply overflows.\n            if lt(totalSupplyAfter, totalSupplyBefore) {\n                mstore(0x00, 0xe5cfe957) // `TotalSupplyOverflow()`.\n                revert(0x1c, 0x04)\n            }\n            // Store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, totalSupplyAfter)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(address(0), to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  INTERNAL BURN FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Burns `amount` tokens from `from`, reducing the total supply.\n    ///\n    /// Emits a {Transfer} event.\n    function _burn(address from, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, address(0), amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the balance slot and load its value.\n            mstore(0x0c, _BALANCE_SLOT_SEED)\n            mstore(0x00, from)\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Subtract and store the updated total supply.\n            sstore(_TOTAL_SUPPLY_SLOT, sub(sload(_TOTAL_SUPPLY_SLOT), amount))\n            // Emit the {Transfer} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)\n        }\n        _afterTokenTransfer(from, address(0), amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL TRANSFER FUNCTIONS                 */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Moves `amount` of tokens from `from` to `to`.\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        _beforeTokenTransfer(from, to, amount);\n        /// @solidity memory-safe-assembly\n        assembly {\n            let from_ := shl(96, from)\n            // Compute the balance slot and load its value.\n            mstore(0x0c, or(from_, _BALANCE_SLOT_SEED))\n            let fromBalanceSlot := keccak256(0x0c, 0x20)\n            let fromBalance := sload(fromBalanceSlot)\n            // Revert if insufficient balance.\n            if gt(amount, fromBalance) {\n                mstore(0x00, 0xf4d678b8) // `InsufficientBalance()`.\n                revert(0x1c, 0x04)\n            }\n            // Subtract and store the updated balance.\n            sstore(fromBalanceSlot, sub(fromBalance, amount))\n            // Compute the balance slot of `to`.\n            mstore(0x00, to)\n            let toBalanceSlot := keccak256(0x0c, 0x20)\n            // Add and store the updated balance of `to`.\n            // Will not overflow because the sum of all user balances\n            // cannot exceed the maximum uint256 value.\n            sstore(toBalanceSlot, add(sload(toBalanceSlot), amount))\n            // Emit the {Transfer} event.\n            mstore(0x20, amount)\n            log3(0x20, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, from_), shr(96, mload(0x0c)))\n        }\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                INTERNAL ALLOWANCE FUNCTIONS                */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Updates the allowance of `owner` for `spender` based on spent `amount`.\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            if (spender == _PERMIT2) return; // Do nothing, as allowance is infinite.\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the allowance slot and load its value.\n            mstore(0x20, spender)\n            mstore(0x0c, _ALLOWANCE_SLOT_SEED)\n            mstore(0x00, owner)\n            let allowanceSlot := keccak256(0x0c, 0x34)\n            let allowance_ := sload(allowanceSlot)\n            // If the allowance is not the maximum uint256 value.\n            if not(allowance_) {\n                // Revert if the amount to be transferred exceeds the allowance.\n                if gt(amount, allowance_) {\n                    mstore(0x00, 0x13be252b) // `InsufficientAllowance()`.\n                    revert(0x1c, 0x04)\n                }\n                // Subtract and store the updated allowance.\n                sstore(allowanceSlot, sub(allowance_, amount))\n            }\n        }\n    }\n\n    /// @dev Sets `amount` as the allowance of `spender` over the tokens of `owner`.\n    ///\n    /// Emits a {Approval} event.\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        if (_givePermit2InfiniteAllowance()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // If `spender == _PERMIT2 && amount != type(uint256).max`.\n                if iszero(or(xor(shr(96, shl(96, spender)), _PERMIT2), iszero(not(amount)))) {\n                    mstore(0x00, 0x3f68539a) // `Permit2AllowanceIsFixedAtInfinity()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n        }\n        /// @solidity memory-safe-assembly\n        assembly {\n            let owner_ := shl(96, owner)\n            // Compute the allowance slot and store the amount.\n            mstore(0x20, spender)\n            mstore(0x0c, or(owner_, _ALLOWANCE_SLOT_SEED))\n            sstore(keccak256(0x0c, 0x34), amount)\n            // Emit the {Approval} event.\n            mstore(0x00, amount)\n            log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, owner_), shr(96, mload(0x2c)))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     HOOKS TO OVERRIDE                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Hook that is called before any transfer of tokens.\n    /// This includes minting and burning.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /// @dev Hook that is called after any transfer of tokens.\n    /// This includes minting and burning.\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          PERMIT2                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns whether to fix the Permit2 contract's allowance at infinity.\n    ///\n    /// This value should be kept constant after contract initialization,\n    /// or else the actual allowance values may not match with the {Approval} events.\n    /// For best performance, return a compile-time constant for zero-cost abstraction.\n    function _givePermit2InfiniteAllowance() internal view virtual returns (bool) {\n        return true;\n    }\n}\n"},"contracts/src/tokens/lock/LockStorage.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\nlibrary LockStorage {\n  // keccak256(\"river.tokens.lock.storage\")\n  bytes32 internal constant STORAGE_SLOT =\n    0xfd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c1;\n\n  struct Layout {\n    uint256 defaultCooldown;\n    mapping(address => bool) enabledByAddress;\n    mapping(address => uint256) expirationByAddress;\n  }\n\n  function layout() internal pure returns (Layout storage l) {\n    assembly {\n      l.slot := STORAGE_SLOT\n    }\n  }\n}\n"},"contracts/src/tokens/towns/base/Towns.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {IERC20Metadata} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\";\nimport {IERC20Permit} from \"@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\";\nimport {IERC6372} from \"@openzeppelin/contracts/interfaces/IERC6372.sol\";\nimport {IVotes} from \"@openzeppelin/contracts/governance/utils/IVotes.sol\";\nimport {IOptimismMintableERC20, ILegacyMintableERC20} from \"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol\";\nimport {ISemver} from \"contracts/src/tokens/towns/base/ISemver.sol\";\nimport {IERC7802} from \"contracts/src/tokens/towns/base/IERC7802.sol\";\n\n// libraries\nimport {CustomRevert} from \"contracts/src/utils/libraries/CustomRevert.sol\";\nimport {TownsLib} from \"./TownsLib.sol\";\n\n// contracts\nimport {IntrospectionBase} from \"@river-build/diamond/src/facets/introspection/IntrospectionBase.sol\";\nimport {Ownable} from \"solady/auth/Ownable.sol\";\nimport {Initializable} from \"solady/utils/Initializable.sol\";\nimport {UUPSUpgradeable} from \"solady/utils/UUPSUpgradeable.sol\";\nimport {ERC20Votes} from \"solady/tokens/ERC20Votes.sol\";\nimport {LockBase} from \"contracts/src/tokens/lock/LockBase.sol\";\n\ncontract Towns is\n  IOptimismMintableERC20,\n  IERC7802,\n  ISemver,\n  IntrospectionBase,\n  LockBase,\n  Initializable,\n  ERC20Votes,\n  UUPSUpgradeable,\n  Ownable\n{\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                          Errors                            */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  error DelegateeSameAsCurrent();\n  error TransferLockEnabled();\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                  Constants & Immutables                    */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice The name of the token\n  string internal constant NAME = \"Towns\";\n\n  /// @notice The symbol of the token\n  string internal constant SYMBOL = \"TOWNS\";\n\n  /// @notice The name hash of the token\n  bytes32 internal constant NAME_HASH = keccak256(bytes(NAME));\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                        Modifiers                           */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice A modifier that only allows the bridge to call\n  modifier onlyL2StandardBridge() {\n    if (msg.sender != TownsLib.L2_STANDARD_BRIDGE) {\n      CustomRevert.revertWith(Unauthorized.selector);\n    }\n    _;\n  }\n\n  /// @notice A modifier that only allows the super chain to call\n  modifier onlyL2SuperChainBridge() {\n    if (msg.sender != TownsLib.SUPERCHAIN_TOKEN_BRIDGE) {\n      CustomRevert.revertWith(Unauthorized.selector);\n    }\n    _;\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                      Initialization                        */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  constructor() {\n    _disableInitializers();\n  }\n\n  function initialize(\n    address _remoteToken,\n    address _owner\n  ) external initializer {\n    // set the owner\n    _initializeOwner(_owner);\n\n    // set the remote token\n    TownsLib.initializeRemoteToken(_remoteToken);\n\n    // initialize the lock\n    __LockBase_init(30 days);\n\n    // add interface\n    _addInterface(type(IERC20).interfaceId);\n    _addInterface(type(IERC20Metadata).interfaceId);\n    _addInterface(type(IERC20Permit).interfaceId);\n    _addInterface(type(IERC6372).interfaceId);\n    _addInterface(type(IERC165).interfaceId);\n    _addInterface(type(IVotes).interfaceId);\n    _addInterface(type(IOptimismMintableERC20).interfaceId);\n    _addInterface(type(ILegacyMintableERC20).interfaceId);\n    _addInterface(type(ISemver).interfaceId);\n    _addInterface(type(IERC7802).interfaceId);\n  }\n\n  /// @notice Semantic version\n  /// @custom:semver 1.0.0-beta.12\n  function version() external view virtual returns (string memory) {\n    return \"1.0.0-beta.12\";\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                        Bridge                              */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @custom:legacy\n  /// @notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\n  function l1Token() external view returns (address) {\n    return TownsLib.layout().remoteToken;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for the bridge. Use BRIDGE going forward.\n  function l2Bridge() external pure returns (address) {\n    return TownsLib.L2_STANDARD_BRIDGE;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for REMOTE_TOKEN\n  function remoteToken() external view returns (address) {\n    return TownsLib.layout().remoteToken;\n  }\n\n  /// @custom:legacy\n  /// @notice Legacy getter for L2_STANDARD_BRIDGE.\n  function bridge() external pure returns (address) {\n    return TownsLib.L2_STANDARD_BRIDGE;\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                      Super Chain                           */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @notice Allows the SuperchainTokenBridge to mint tokens.\n  /// @param _to     Address to mint tokens to.\n  /// @param _amount Amount of tokens to mint.\n  function crosschainMint(\n    address _to,\n    uint256 _amount\n  ) external onlyL2SuperChainBridge {\n    _mint(_to, _amount);\n    emit CrosschainMint(_to, _amount, msg.sender);\n  }\n\n  /// @notice Allows the SuperchainTokenBridge to burn tokens.\n  /// @param _from   Address to burn tokens from.\n  /// @param _amount Amount of tokens to burn.\n  function crosschainBurn(\n    address _from,\n    uint256 _amount\n  ) external onlyL2SuperChainBridge {\n    _burn(_from, _amount);\n    emit CrosschainBurn(_from, _amount, msg.sender);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                     Introspection                          */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  /// @inheritdoc IERC165\n  function supportsInterface(\n    bytes4 interfaceId\n  ) public view virtual override returns (bool) {\n    return _supportsInterface(interfaceId);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                           Lock                               */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function isLockActive(address account) external view virtual returns (bool) {\n    return _isLockActive(account);\n  }\n\n  function lockExpiration(\n    address account\n  ) external view virtual returns (uint256) {\n    return _lockExpiration(account);\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                         Overrides                          */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function name() public pure override returns (string memory) {\n    return NAME;\n  }\n\n  function symbol() public pure override returns (string memory) {\n    return SYMBOL;\n  }\n\n  function decimals() public pure override returns (uint8) {\n    return 18;\n  }\n\n  /// @notice Allows the StandardBridge on this network to mint tokens.\n  /// @param to     Address to mint tokens to.\n  /// @param amount Amount of tokens to mint.\n  function mint(\n    address to,\n    uint256 amount\n  ) external override(IOptimismMintableERC20) onlyL2StandardBridge {\n    _mint(to, amount);\n  }\n\n  /// @notice Allows the StandardBridge on this network to burn tokens.\n  /// @param from     Address to burn tokens from.\n  /// @param amount Amount of tokens to burn.\n  function burn(\n    address from,\n    uint256 amount\n  ) external override(IOptimismMintableERC20) onlyL2StandardBridge {\n    _burn(from, amount);\n  }\n\n  /// @notice Clock used for flagging checkpoints, overridden to implement timestamp based\n  /// checkpoints (and voting).\n  function clock() public view override returns (uint48) {\n    return uint48(block.timestamp);\n  }\n\n  /// @notice Machine-readable description of the clock as specified in EIP-6372.\n  function CLOCK_MODE() public pure override returns (string memory) {\n    return \"mode=timestamp\";\n  }\n\n  /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n  /*                     Internal Overrides                     */\n  /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n  function _beforeTokenTransfer(\n    address from,\n    address to,\n    uint256 amount\n  ) internal override {\n    if (from != address(0) && _isLockActive(from)) {\n      // allow transferring at minting time\n      CustomRevert.revertWith(TransferLockEnabled.selector);\n    }\n\n    super._beforeTokenTransfer(from, to, amount);\n  }\n\n  function _delegate(address account, address delegatee) internal override {\n    address currentDelegatee = delegates(account);\n\n    // revert if the delegatee is the same as the current delegatee\n    if (currentDelegatee == delegatee)\n      CustomRevert.revertWith(DelegateeSameAsCurrent.selector);\n\n    // if the delegatee is the zero address, initialize disable lock\n    if (delegatee == address(0)) {\n      _disableLock(account);\n    } else {\n      _enableLock(account);\n    }\n\n    super._delegate(account, delegatee);\n  }\n\n  /// @dev Override the name hash to be a constant value for performance in EIP-712\n  function _constantNameHash() internal pure override returns (bytes32) {\n    return NAME_HASH;\n  }\n\n  /// @dev This allows Permit2 to be used without prior approval.\n  function _givePermit2InfiniteAllowance()\n    internal\n    pure\n    override\n    returns (bool)\n  {\n    return true;\n  }\n\n  /// @dev Override the default lock check to disable it.\n  function _canLock() internal pure override returns (bool) {\n    return false;\n  }\n\n  /// @notice Override the default upgrade check to only allow the owner.\n  function _authorizeUpgrade(\n    address newImplementation\n  ) internal override onlyOwner {}\n}\n"},"contracts/src/tokens/towns/base/ISemver.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title ISemver\n/// @notice ISemver is a simple contract for ensuring that contracts are\n///         versioned using semantic versioning.\ninterface ISemver {\n  /// @notice Getter for the semantic version of the contract. This is not\n  ///         meant to be used onchain but instead meant to be used by offchain\n  ///         tooling.\n  /// @return Semver contract version as a string.\n  function version() external view returns (string memory);\n}\n"},"contracts/src/tokens/towns/base/IERC7802.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC165} from \"@openzeppelin/contracts/interfaces/IERC165.sol\";\n\n/// @title IERC7802\n/// @notice Defines the interface for crosschain ERC20 transfers.\ninterface IERC7802 is IERC165 {\n  /// @notice Emitted when a crosschain transfer mints tokens.\n  /// @param to       Address of the account tokens are being minted for.\n  /// @param amount   Amount of tokens minted.\n  /// @param sender   Address of the account that finalized the crosschain transfer.\n  event CrosschainMint(\n    address indexed to,\n    uint256 amount,\n    address indexed sender\n  );\n\n  /// @notice Emitted when a crosschain transfer burns tokens.\n  /// @param from     Address of the account tokens are being burned from.\n  /// @param amount   Amount of tokens burned.\n  /// @param sender   Address of the account that initiated the crosschain transfer.\n  event CrosschainBurn(\n    address indexed from,\n    uint256 amount,\n    address indexed sender\n  );\n\n  /// @notice Mint tokens through a crosschain transfer.\n  /// @param _to     Address to mint tokens to.\n  /// @param _amount Amount of tokens to mint.\n  function crosschainMint(address _to, uint256 _amount) external;\n\n  /// @notice Burn tokens through a crosschain transfer.\n  /// @param _from   Address to burn tokens from.\n  /// @param _amount Amount of tokens to burn.\n  function crosschainBurn(address _from, uint256 _amount) external;\n}\n"},"contracts/src/tokens/towns/base/TownsLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title TownsLib\nlibrary TownsLib {\n  /// @notice Address of the L2StandardBridge predeploy.\n  address internal constant L2_STANDARD_BRIDGE =\n    0x4200000000000000000000000000000000000010;\n\n  /// @notice Address of the SuperchainTokenBridge predeploy.\n  address internal constant SUPERCHAIN_TOKEN_BRIDGE =\n    0x4200000000000000000000000000000000000028;\n\n  // keccak256(abi.encode(uint256(keccak256(\"towns.tokens.l2.storage\")) - 1)) & ~bytes32(uint256(0xff))\n  bytes32 constant STORAGE_SLOT =\n    0x708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b00;\n\n  struct Layout {\n    address remoteToken;\n  }\n\n  function layout() internal pure returns (Layout storage l) {\n    assembly {\n      l.slot := STORAGE_SLOT\n    }\n  }\n\n  function initializeRemoteToken(address _remoteToken) internal {\n    Layout storage l = layout();\n    l.remoteToken = _remoteToken;\n  }\n}\n"},"node_modules/solady/src/tokens/ERC20Votes.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {ERC20} from \"./ERC20.sol\";\n\n/// @notice ERC20 with votes based on ERC5805 and ERC6372.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20Votes.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/extensions/ERC20Votes.sol)\nabstract contract ERC20Votes is ERC20 {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The timepoint is in the future.\n    error ERC5805FutureLookup();\n\n    /// @dev The ERC5805 signature to set a delegate has expired.\n    error ERC5805DelegateSignatureExpired();\n\n    /// @dev The ERC5805 signature to set a delegate is invalid.\n    error ERC5805DelegateInvalidSignature();\n\n    /// @dev Out-of-bounds access for the checkpoints.\n    error ERC5805CheckpointIndexOutOfBounds();\n\n    /// @dev Arithmetic overflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueOverflow();\n\n    /// @dev Arithmetic underflow when pushing a new checkpoint.\n    error ERC5805CheckpointValueUnderflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The delegate of `delegator` is changed from `from` to `to`.\n    event DelegateChanged(address indexed delegator, address indexed from, address indexed to);\n\n    /// @dev The votes balance of `delegate` is changed from `oldValue` to `newValue`.\n    event DelegateVotesChanged(address indexed delegate, uint256 oldValue, uint256 newValue);\n\n    /// @dev `keccak256(bytes(\"DelegateChanged(address,address,address)\"))`.\n    uint256 private constant _DELEGATE_CHANGED_EVENT_SIGNATURE =\n        0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f;\n\n    /// @dev `keccak256(bytes(\"DelegateVotesChanged(address,uint256,uint256)\"))`.\n    uint256 private constant _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE =\n        0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev `keccak256(\"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)\")`.\n    bytes32 private constant _DOMAIN_TYPEHASH =\n        0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;\n\n    /// @dev `keccak256(\"Delegation(address delegatee,uint256 nonce,uint256 expiry)\")`.\n    bytes32 private constant _ERC5805_DELEGATION_TYPEHASH =\n        0xe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, account)\n    ///     let delegateSlot := keccak256(0x0c, 0x18)\n    /// ```\n    /// The checkpoints length slot of a delegate is given by:\n    /// ```\n    ///     mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n    ///     mstore(0x00, delegate)\n    ///     let lengthSlot := keccak256(0x0c, 0x17)\n    ///     let length := and(0xffffffffffff, shr(48, sload(lengthSlot)))\n    /// ```\n    /// The total checkpoints length slot is `_ERC20_VOTES_MASTER_SLOT_SEED << 96`.\n    ///\n    /// The `i`-th checkpoint slot is given by:\n    /// ```\n    ///     let checkpointSlot := add(i, lengthSlot)\n    ///     let key := and(sload(checkpointSlot), 0xffffffffffff)\n    ///     let value := shr(96, sload(checkpointSlot))\n    ///     if eq(value, address()) { value := sload(not(checkpointSlot)) }\n    /// ```\n    uint256 private constant _ERC20_VOTES_MASTER_SLOT_SEED = 0xff466c9f;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC6372                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the clock mode.\n    function CLOCK_MODE() public view virtual returns (string memory) {\n        return \"mode=blocknumber&from=default\";\n    }\n\n    /// @dev Returns the current clock.\n    function clock() public view virtual returns (uint48 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := number()\n            // Branch-less out-of-gas revert if `block.number >= 2 ** 48`.\n            returndatacopy(returndatasize(), returndatasize(), sub(0, shr(48, number())))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          ERC5805                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the latest amount of voting units for `account`.\n    function getVotes(address account) public view virtual returns (uint256) {\n        return _checkpointLatest(_delegateCheckpointsSlot(account));\n    }\n\n    /// @dev Returns the latest amount of voting units `account` has before or during `timepoint`.\n    function getPastVotes(address account, uint256 timepoint)\n        public\n        view\n        virtual\n        returns (uint256)\n    {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_delegateCheckpointsSlot(account), timepoint);\n    }\n\n    /// @dev Returns the current voting delegate of `delegator`.\n    function delegates(address delegator) public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, delegator)\n            result := sload(keccak256(0x0c, 0x18))\n        }\n    }\n\n    /// @dev Set the voting delegate of the caller to `delegatee`.\n    function delegate(address delegatee) public virtual {\n        _delegate(msg.sender, delegatee);\n    }\n\n    /// @dev Sets the voting delegate of the signature signer to `delegatee`.\n    function delegateBySig(\n        address delegatee,\n        uint256 nonce,\n        uint256 expiry,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) public virtual {\n        address signer;\n        bytes32 nameHash = _constantNameHash();\n        //  We simply calculate it on-the-fly to allow for cases where the `name` may change.\n        if (nameHash == bytes32(0)) nameHash = keccak256(bytes(name()));\n        bytes32 versionHash = _versionHash();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if gt(timestamp(), expiry) {\n                mstore(0x00, 0x3480e9e1) // `ERC5805DelegateSignatureExpired()`.\n                revert(0x1c, 0x04)\n            }\n            let m := mload(0x40)\n            // Prepare the struct hash.\n            mstore(0x00, _ERC5805_DELEGATION_TYPEHASH)\n            mstore(0x20, shr(96, shl(96, delegatee)))\n            mstore(0x40, nonce)\n            mstore(0x60, expiry)\n            mstore(0x40, keccak256(0x00, 0x80))\n            mstore(0x00, 0x1901) // Store \"\\x19\\x01\".\n            // Prepare the domain separator.\n            mstore(m, _DOMAIN_TYPEHASH)\n            mstore(add(m, 0x20), nameHash)\n            mstore(add(m, 0x40), versionHash)\n            mstore(add(m, 0x60), chainid())\n            mstore(add(m, 0x80), address())\n            mstore(0x20, keccak256(m, 0xa0))\n            // Prepare the ecrecover calldata.\n            mstore(0x00, keccak256(0x1e, 0x42))\n            mstore(0x20, and(0xff, v))\n            mstore(0x40, r)\n            mstore(0x60, s)\n            signer := mload(staticcall(gas(), 1, 0x00, 0x80, 0x01, 0x20))\n            mstore(0x40, m) // Restore the free memory pointer.\n            mstore(0x60, 0) // Restore the zero pointer.\n            // `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.\n            expiry := iszero(returndatasize()) // Reuse `expiry` to denote `ecrecover` failure.\n        }\n        if ((nonces(signer) ^ nonce) | expiry != 0) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                mstore(0x00, 0x1838d95c) // `ERC5805DelegateInvalidSignature()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _incrementNonce(signer);\n        _delegate(signer, delegatee);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*              OTHER VOTE PUBLIC VIEW FUNCTIONS              */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the number of checkpoints for `account`.\n    function checkpointCount(address account) public view virtual returns (uint256 result) {\n        result = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(result)))\n        }\n    }\n\n    /// @dev Returns the voting checkpoint for `account` at index `i`.\n    function checkpointAt(address account, uint256 i)\n        public\n        view\n        virtual\n        returns (uint48 checkpointClock, uint256 checkpointValue)\n    {\n        uint256 lengthSlot = _delegateCheckpointsSlot(account);\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(lt(i, shr(208, shl(160, sload(lengthSlot))))) {\n                mstore(0x00, 0x86df9d10) // `ERC5805CheckpointIndexOutOfBounds()`.\n                revert(0x1c, 0x04)\n            }\n            let checkpointPacked := sload(add(i, lengthSlot))\n            checkpointClock := and(0xffffffffffff, checkpointPacked)\n            checkpointValue := shr(96, checkpointPacked)\n            if eq(checkpointValue, address()) { checkpointValue := sload(not(add(i, lengthSlot))) }\n        }\n    }\n\n    /// @dev Returns the latest amount of total voting units.\n    function getVotesTotalSupply() public view virtual returns (uint256) {\n        return _checkpointLatest(_ERC20_VOTES_MASTER_SLOT_SEED << 96);\n    }\n\n    /// @dev Returns the latest amount of total voting units before or during `timepoint`.\n    function getPastVotesTotalSupply(uint256 timepoint) public view virtual returns (uint256) {\n        if (timepoint >= clock()) _revertERC5805FutureLookup();\n        return _checkpointUpperLookupRecent(_ERC20_VOTES_MASTER_SLOT_SEED << 96, timepoint);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the amount of voting units `delegator` has control over.\n    /// Override if you need a different formula.\n    function _getVotingUnits(address delegator) internal view virtual returns (uint256) {\n        return balanceOf(delegator);\n    }\n\n    /// @dev ERC20 after token transfer internal hook.\n    function _afterTokenTransfer(address from, address to, uint256 amount)\n        internal\n        virtual\n        override\n    {\n        _transferVotingUnits(from, to, amount);\n    }\n\n    /// @dev Used in `_afterTokenTransfer(address from, address to, uint256 amount)`.\n    function _transferVotingUnits(address from, address to, uint256 amount) internal virtual {\n        if (from == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, true);\n        }\n        if (to == address(0)) {\n            _checkpointPushDiff(_ERC20_VOTES_MASTER_SLOT_SEED << 96, clock(), amount, false);\n        }\n        _moveDelegateVotes(delegates(from), delegates(to), amount);\n    }\n\n    /// @dev Transfer `amount` of delegated votes from `from` to `to`.\n    /// Emits a {DelegateVotesChanged} event for each change of delegated votes.\n    function _moveDelegateVotes(address from, address to, uint256 amount) internal virtual {\n        if (amount == uint256(0)) return;\n        (uint256 fromCleaned, uint256 toCleaned) = (uint256(uint160(from)), uint256(uint160(to)));\n        if (fromCleaned == toCleaned) return;\n        if (fromCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(from), clock(), amount, false);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, fromCleaned)\n            }\n        }\n        if (toCleaned != 0) {\n            (uint256 oldValue, uint256 newValue) =\n                _checkpointPushDiff(_delegateCheckpointsSlot(to), clock(), amount, true);\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Emit the {DelegateVotesChanged} event.\n                mstore(0x00, oldValue)\n                mstore(0x20, newValue)\n                log2(0x00, 0x40, _DELEGATE_VOTES_CHANGED_EVENT_SIGNATURE, toCleaned)\n            }\n        }\n    }\n\n    /// @dev Delegates all of `account`'s voting units to `delegatee`.\n    /// Emits the {DelegateChanged} and {DelegateVotesChanged} events.\n    function _delegate(address account, address delegatee) internal virtual {\n        address from;\n        /// @solidity memory-safe-assembly\n        assembly {\n            let to := shr(96, shl(96, delegatee))\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            let delegateSlot := keccak256(0x0c, 0x18)\n            from := sload(delegateSlot)\n            sstore(delegateSlot, to)\n            // Emit the {DelegateChanged} event.\n            log4(0x00, 0x00, _DELEGATE_CHANGED_EVENT_SIGNATURE, shr(96, mload(0x0c)), from, to)\n        }\n        _moveDelegateVotes(from, delegatee, _getVotingUnits(account));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      PRIVATE HELPERS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the delegate checkpoints slot for `account`.\n    function _delegateCheckpointsSlot(address account) private pure returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x04, _ERC20_VOTES_MASTER_SLOT_SEED)\n            mstore(0x00, account)\n            result := keccak256(0x0c, 0x17)\n        }\n    }\n\n    /// @dev Pushes a checkpoint.\n    function _checkpointPushDiff(uint256 lengthSlot, uint256 key, uint256 amount, bool isAdd)\n        private\n        returns (uint256 oldValue, uint256 newValue)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let lengthSlotPacked := sload(lengthSlot)\n            for { let n := shr(208, shl(160, lengthSlotPacked)) } 1 {} {\n                if iszero(n) {\n                    if iszero(or(isAdd, iszero(amount))) {\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := amount\n                    if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                        sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, newValue)))\n                        break\n                    }\n                    sstore(lengthSlot, or(or(key, shl(48, 1)), shl(96, address())))\n                    sstore(not(lengthSlot), newValue)\n                    break\n                }\n                let checkpointSlot := add(sub(n, 1), lengthSlot)\n                let lastPacked := sload(checkpointSlot)\n                oldValue := shr(96, lastPacked)\n                if eq(oldValue, address()) { oldValue := sload(not(checkpointSlot)) }\n                for {} 1 {} {\n                    if iszero(isAdd) {\n                        newValue := sub(oldValue, amount)\n                        if iszero(gt(newValue, oldValue)) { break }\n                        mstore(0x00, 0x5915f686) // `ERC5805CheckpointValueUnderflow()`.\n                        revert(0x1c, 0x04)\n                    }\n                    newValue := add(oldValue, amount)\n                    if iszero(lt(newValue, oldValue)) { break }\n                    mstore(0x00, 0x9dbbeb75) // `ERC5805CheckpointValueOverflow()`.\n                    revert(0x1c, 0x04)\n                }\n                let lastKey := and(0xffffffffffff, lastPacked)\n                if iszero(eq(lastKey, key)) {\n                    n := add(1, n)\n                    checkpointSlot := add(1, checkpointSlot)\n                    sstore(lengthSlot, add(shl(48, 1), lengthSlotPacked))\n                }\n                if or(gt(lastKey, key), shr(48, n)) { invalid() }\n                if iszero(or(eq(newValue, address()), shr(160, newValue))) {\n                    sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, newValue)))\n                    break\n                }\n                sstore(checkpointSlot, or(or(key, shl(48, n)), shl(96, address())))\n                sstore(not(checkpointSlot), newValue)\n                break\n            }\n        }\n    }\n\n    /// @dev Returns the latest value in the checkpoints.\n    function _checkpointLatest(uint256 lengthSlot) private view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := shr(208, shl(160, sload(lengthSlot)))\n            if result {\n                lengthSlot := add(sub(result, 1), lengthSlot) // Reuse for `checkpointSlot`.\n                result := shr(96, sload(lengthSlot))\n                if eq(result, address()) { result := sload(not(lengthSlot)) }\n            }\n        }\n    }\n\n    /// @dev Returns checkpoint value with the largest key that is less than or equal to `key`.\n    function _checkpointUpperLookupRecent(uint256 lengthSlot, uint256 key)\n        private\n        view\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let l := 0 // Low.\n            let h := shr(208, shl(160, sload(lengthSlot))) // High.\n            // Start the binary search nearer to the right to optimize for recent checkpoints.\n            for {} iszero(lt(h, 6)) {} {\n                let m := shl(4, lt(0xffff, h))\n                m := shl(shr(1, or(m, shl(3, lt(0xff, shr(m, h))))), 16)\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := shr(1, add(m, div(h, m)))\n                m := sub(h, shr(1, add(m, div(h, m)))) // Approx `h - sqrt(h)`.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    break\n                }\n                h := m\n                break\n            }\n            // Binary search.\n            for {} lt(l, h) {} {\n                let m := shr(1, add(l, h)) // Won't overflow in practice.\n                if iszero(lt(key, and(sload(add(m, lengthSlot)), 0xffffffffffff))) {\n                    l := add(1, m)\n                    continue\n                }\n                h := m\n            }\n            let checkpointSlot := add(sub(h, 1), lengthSlot)\n            result := mul(iszero(iszero(h)), shr(96, sload(checkpointSlot)))\n            if eq(result, address()) { result := sload(not(checkpointSlot)) }\n        }\n    }\n\n    /// @dev Reverts with `ERC5805FutureLookup()`.\n    function _revertERC5805FutureLookup() private pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0xf9874464) // `ERC5805FutureLookup()`.\n            revert(0x1c, 0x04)\n        }\n    }\n}\n"},"contracts/src/utils/libraries/CustomRevert.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Library for reverting with custom errors efficiently\n/// @notice Contains functions for reverting with custom errors with different argument types efficiently\n/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with\n/// `CustomError.selector.revertWith()`\n/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately\nlibrary CustomRevert {\n  /// @dev Reverts with the selector of a custom error in the scratch space\n  function revertWith(bytes4 selector) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      revert(0, 0x04)\n    }\n  }\n\n  /// @dev Reverts with a custom error with a uint256 argument in the scratch space\n  function revertWith(bytes4 selector, uint256 value) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      mstore(0x04, value)\n      revert(0, 0x24)\n    }\n  }\n\n  /// @dev Reverts with a custom error with an address argument in the scratch space\n  function revertWith(bytes4 selector, address addr) internal pure {\n    assembly (\"memory-safe\") {\n      mstore(0, selector)\n      mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))\n      revert(0, 0x24)\n    }\n  }\n}\n"},"node_modules/solady/src/utils/Initializable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Initializable mixin for the upgradeable contracts.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Initializable.sol)\n/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy/utils/Initializable.sol)\nabstract contract Initializable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The contract is already initialized.\n    error InvalidInitialization();\n\n    /// @dev The contract is not initializing.\n    error NotInitializing();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Triggered when the contract has been initialized.\n    event Initialized(uint64 version);\n\n    /// @dev `keccak256(bytes(\"Initialized(uint64)\"))`.\n    bytes32 private constant _INTIALIZED_EVENT_SIGNATURE =\n        0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The default initializable slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_INITIALIZABLE_SLOT\")))))`.\n    ///\n    /// Bits Layout:\n    /// - [0]     `initializing`\n    /// - [1..64] `initializedVersion`\n    bytes32 private constant _INITIALIZABLE_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf601132;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                        CONSTRUCTOR                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    constructor() {\n        // Construction time check to ensure that `_initializableSlot()` is not\n        // overridden to zero. Will be optimized away if there is no revert.\n        require(_initializableSlot() != bytes32(0));\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         OPERATIONS                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return a non-zero custom storage slot if required.\n    function _initializableSlot() internal pure virtual returns (bytes32) {\n        return _INITIALIZABLE_SLOT;\n    }\n\n    /// @dev Guards an initializer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `initializer`.\n    ///\n    /// This is similar to `reinitializer(1)`, except that in the context of a constructor,\n    /// an `initializer` guarded function can be invoked multiple times.\n    /// This can be useful during testing and is not expected to be used in production.\n    ///\n    /// Emits an {Initialized} event.\n    modifier initializer() virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            // Set `initializing` to 1, `initializedVersion` to 1.\n            sstore(s, 3)\n            // If `!(initializing == 0 && initializedVersion == 0)`.\n            if i {\n                // If `!(address(this).code.length == 0 && initializedVersion == 1)`.\n                if iszero(lt(extcodesize(address()), eq(shr(1, i), 1))) {\n                    mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                    revert(0x1c, 0x04)\n                }\n                s := shl(shl(255, i), s) // Skip initializing if `initializing == 1`.\n            }\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if s {\n                // Set `initializing` to 0, `initializedVersion` to 1.\n                sstore(s, 2)\n                // Emit the {Initialized} event.\n                mstore(0x20, 1)\n                log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Guards an reinitialzer function so that it can be invoked at most once.\n    ///\n    /// You can guard a function with `onlyInitializing` such that it can be called\n    /// through a function guarded with `reinitializer`.\n    ///\n    /// Emits an {Initialized} event.\n    modifier reinitializer(uint64 version) virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Clean upper bits, and shift left by 1 to make space for the initializing bit.\n            version := shl(1, and(version, 0xffffffffffffffff))\n            let i := sload(s)\n            // If `initializing == 1 || initializedVersion >= version`.\n            if iszero(lt(and(i, 1), lt(i, version))) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            // Set `initializing` to 1, `initializedVersion` to `version`.\n            sstore(s, or(1, version))\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Set `initializing` to 0, `initializedVersion` to `version`.\n            sstore(s, version)\n            // Emit the {Initialized} event.\n            mstore(0x20, shr(1, version))\n            log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n        }\n    }\n\n    /// @dev Guards a function such that it can only be called in the scope\n    /// of a function guarded with `initializer` or `reinitializer`.\n    modifier onlyInitializing() virtual {\n        _checkInitializing();\n        _;\n    }\n\n    /// @dev Reverts if the contract is not initializing.\n    function _checkInitializing() internal view virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(and(1, sload(s))) {\n                mstore(0x00, 0xd7e6bcf8) // `NotInitializing()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Locks any future initializations by setting the initialized version to `2**64 - 1`.\n    ///\n    /// Calling this in the constructor will prevent the contract from being initialized\n    /// or reinitialized. It is recommended to use this to lock implementation contracts\n    /// that are designed to be called through proxies.\n    ///\n    /// Emits an {Initialized} event the first time it is successfully called.\n    function _disableInitializers() internal virtual {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            let i := sload(s)\n            if and(i, 1) {\n                mstore(0x00, 0xf92ee8a9) // `InvalidInitialization()`.\n                revert(0x1c, 0x04)\n            }\n            let uint64max := 0xffffffffffffffff\n            if iszero(eq(shr(1, i), uint64max)) {\n                // Set `initializing` to 0, `initializedVersion` to `2**64 - 1`.\n                sstore(s, shl(1, uint64max))\n                // Emit the {Initialized} event.\n                mstore(0x20, uint64max)\n                log1(0x20, 0x20, _INTIALIZED_EVENT_SIGNATURE)\n            }\n        }\n    }\n\n    /// @dev Returns the highest version that has been initialized.\n    function _getInitializedVersion() internal view virtual returns (uint64 version) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            version := shr(1, sload(s))\n        }\n    }\n\n    /// @dev Returns whether the contract is currently initializing.\n    function _isInitializing() internal view virtual returns (bool result) {\n        bytes32 s = _initializableSlot();\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := and(1, sload(s))\n        }\n    }\n}\n"},"node_modules/solady/src/utils/UUPSUpgradeable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice UUPS proxy mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/UUPSUpgradeable.sol)\n/// @author Modified from OpenZeppelin\n/// (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/utils/UUPSUpgradeable.sol)\n///\n/// @dev Note:\n/// - This implementation is intended to be used with ERC1967 proxies.\n/// See: `LibClone.deployERC1967` and related functions.\n/// - This implementation is NOT compatible with legacy OpenZeppelin proxies\n/// which do not store the implementation at `_ERC1967_IMPLEMENTATION_SLOT`.\nabstract contract UUPSUpgradeable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The upgrade failed.\n    error UpgradeFailed();\n\n    /// @dev The call is from an unauthorized call context.\n    error UnauthorizedCallContext();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         IMMUTABLES                         */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev For checking if the context is a delegate call.\n    uint256 private immutable __self = uint256(uint160(address(this)));\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Emitted when the proxy's implementation is upgraded.\n    event Upgraded(address indexed implementation);\n\n    /// @dev `keccak256(bytes(\"Upgraded(address)\"))`.\n    uint256 private constant _UPGRADED_EVENT_SIGNATURE =\n        0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ERC-1967 storage slot for the implementation in the proxy.\n    /// `uint256(keccak256(\"eip1967.proxy.implementation\")) - 1`.\n    bytes32 internal constant _ERC1967_IMPLEMENTATION_SLOT =\n        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      UUPS OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Please override this function to check if `msg.sender` is authorized\n    /// to upgrade the proxy to `newImplementation`, reverting if not.\n    /// ```\n    ///     function _authorizeUpgrade(address) internal override onlyOwner {}\n    /// ```\n    function _authorizeUpgrade(address newImplementation) internal virtual;\n\n    /// @dev Returns the storage slot used by the implementation,\n    /// as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822).\n    ///\n    /// Note: The `notDelegated` modifier prevents accidental upgrades to\n    /// an implementation that is a proxy contract.\n    function proxiableUUID() public view virtual notDelegated returns (bytes32) {\n        // This function must always return `_ERC1967_IMPLEMENTATION_SLOT` to comply with ERC1967.\n        return _ERC1967_IMPLEMENTATION_SLOT;\n    }\n\n    /// @dev Upgrades the proxy's implementation to `newImplementation`.\n    /// Emits a {Upgraded} event.\n    ///\n    /// Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\n    function upgradeToAndCall(address newImplementation, bytes calldata data)\n        public\n        payable\n        virtual\n        onlyProxy\n    {\n        _authorizeUpgrade(newImplementation);\n        /// @solidity memory-safe-assembly\n        assembly {\n            newImplementation := shr(96, shl(96, newImplementation)) // Clears upper 96 bits.\n            mstore(0x00, returndatasize())\n            mstore(0x01, 0x52d1902d) // `proxiableUUID()`.\n            let s := _ERC1967_IMPLEMENTATION_SLOT\n            // Check if `newImplementation` implements `proxiableUUID` correctly.\n            if iszero(eq(mload(staticcall(gas(), newImplementation, 0x1d, 0x04, 0x01, 0x20)), s)) {\n                mstore(0x01, 0x55299b49) // `UpgradeFailed()`.\n                revert(0x1d, 0x04)\n            }\n            // Emit the {Upgraded} event.\n            log2(codesize(), 0x00, _UPGRADED_EVENT_SIGNATURE, newImplementation)\n            sstore(s, newImplementation) // Updates the implementation.\n\n            // Perform a delegatecall to `newImplementation` if `data` is non-empty.\n            if data.length {\n                // Forwards the `data` to `newImplementation` via delegatecall.\n                let m := mload(0x40)\n                calldatacopy(m, data.offset, data.length)\n                if iszero(delegatecall(gas(), newImplementation, m, data.length, codesize(), 0x00))\n                {\n                    // Bubble up the revert if the call reverts.\n                    returndatacopy(m, 0x00, returndatasize())\n                    revert(m, returndatasize())\n                }\n            }\n        }\n    }\n\n    /// @dev Requires that the execution is performed through a proxy.\n    modifier onlyProxy() {\n        uint256 s = __self;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // To enable use cases with an immutable default implementation in the bytecode,\n            // (see: ERC6551Proxy), we don't require that the proxy address must match the\n            // value stored in the implementation slot, which may not be initialized.\n            if eq(s, address()) {\n                mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _;\n    }\n\n    /// @dev Requires that the execution is NOT performed via delegatecall.\n    /// This is the opposite of `onlyProxy`.\n    modifier notDelegated() {\n        uint256 s = __self;\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(eq(s, address())) {\n                mstore(0x00, 0x9f03a026) // `UnauthorizedCallContext()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _;\n    }\n}\n"},"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\n\n/// @title IOptimismMintableERC20\n/// @notice This interface is available on the OptimismMintableERC20 contract.\n///         We declare it as a separate interface so that it can be used in\n///         custom implementations of OptimismMintableERC20.\ninterface IOptimismMintableERC20 is IERC165 {\n  function remoteToken() external view returns (address);\n\n  function bridge() external returns (address);\n\n  function mint(address _to, uint256 _amount) external;\n\n  function burn(address _from, uint256 _amount) external;\n}\n\n/// @custom:legacy\n/// @title ILegacyMintableERC20\n/// @notice This interface was available on the legacy L2StandardERC20 contract.\n///         It remains available on the OptimismMintableERC20 contract for\n///         backwards compatibility.\ninterface ILegacyMintableERC20 is IERC165 {\n  function l1Token() external view returns (address);\n\n  function mint(address _to, uint256 _amount) external;\n\n  function burn(address _from, uint256 _amount) external;\n}\n"},"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC6372.sol)\n\npragma solidity ^0.8.20;\n\ninterface IERC6372 {\n    /**\n     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).\n     */\n    function clock() external view returns (uint48);\n\n    /**\n     * @dev Description of the clock\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function CLOCK_MODE() external view returns (string memory);\n}\n"},"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (governance/utils/IVotes.sol)\npragma solidity ^0.8.20;\n\n/**\n * @dev Common interface for {ERC20Votes}, {ERC721Votes}, and other {Votes}-enabled contracts.\n */\ninterface IVotes {\n    /**\n     * @dev The signature used has expired.\n     */\n    error VotesExpiredSignature(uint256 expiry);\n\n    /**\n     * @dev Emitted when an account changes their delegate.\n     */\n    event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);\n\n    /**\n     * @dev Emitted when a token transfer or delegate change results in changes to a delegate's number of voting units.\n     */\n    event DelegateVotesChanged(address indexed delegate, uint256 previousVotes, uint256 newVotes);\n\n    /**\n     * @dev Returns the current amount of votes that `account` has.\n     */\n    function getVotes(address account) external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of votes that `account` had at a specific moment in the past. If the `clock()` is\n     * configured to use block numbers, this will return the value at the end of the corresponding block.\n     */\n    function getPastVotes(address account, uint256 timepoint) external view returns (uint256);\n\n    /**\n     * @dev Returns the total supply of votes available at a specific moment in the past. If the `clock()` is\n     * configured to use block numbers, this will return the value at the end of the corresponding block.\n     *\n     * NOTE: This value is the sum of all available votes, which is not necessarily the sum of all delegated votes.\n     * Votes that have not been delegated are still part of total supply, even though they would not participate in a\n     * vote.\n     */\n    function getPastTotalSupply(uint256 timepoint) external view returns (uint256);\n\n    /**\n     * @dev Returns the delegate that `account` has chosen.\n     */\n    function delegates(address account) external view returns (address);\n\n    /**\n     * @dev Delegates votes from the sender to `delegatee`.\n     */\n    function delegate(address delegatee) external;\n\n    /**\n     * @dev Delegates votes from signer to `delegatee`.\n     */\n    function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;\n}\n"},"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Permit.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Interface of the ERC-20 Permit extension allowing approvals to be made via signatures, as defined in\n * https://eips.ethereum.org/EIPS/eip-2612[ERC-2612].\n *\n * Adds the {permit} method, which can be used to change an account's ERC-20 allowance (see {IERC20-allowance}) by\n * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't\n * need to send a transaction, and thus is not required to hold Ether at all.\n *\n * ==== Security Considerations\n *\n * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature\n * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be\n * considered as an intention to spend the allowance in any specific way. The second is that because permits have\n * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should\n * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be\n * generally recommended is:\n *\n * ```solidity\n * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {\n *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}\n *     doThing(..., value);\n * }\n *\n * function doThing(..., uint256 value) public {\n *     token.safeTransferFrom(msg.sender, address(this), value);\n *     ...\n * }\n * ```\n *\n * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of\n * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also\n * {SafeERC20-safeTransferFrom}).\n *\n * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so\n * contracts should have entry points that don't rely on permit.\n */\ninterface IERC20Permit {\n    /**\n     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,\n     * given ``owner``'s signed approval.\n     *\n     * IMPORTANT: The same issues {IERC20-approve} has related to transaction\n     * ordering also apply here.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `deadline` must be a timestamp in the future.\n     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`\n     * over the EIP712-formatted function arguments.\n     * - the signature must use ``owner``'s current nonce (see {nonces}).\n     *\n     * For more information on the signature format, see the\n     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP\n     * section].\n     *\n     * CAUTION: See Security Considerations above.\n     */\n    function permit(\n        address owner,\n        address spender,\n        uint256 value,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n\n    /**\n     * @dev Returns the current nonce for `owner`. This value must be\n     * included whenever a signature is generated for {permit}.\n     *\n     * Every successful call to {permit} increases ``owner``'s nonce by one. This\n     * prevents a signature from being used multiple times.\n     */\n    function nonces(address owner) external view returns (uint256);\n\n    /**\n     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\n\npragma solidity ^0.8.20;\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"},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\nimport {IERC165} from \"@openzeppelin/contracts/utils/introspection/IERC165.sol\";\nimport {IIntrospectionBase} from \"./IIntrospectionBase.sol\";\n\n// libraries\nimport {IntrospectionStorage} from \"./IntrospectionStorage.sol\";\n\nabstract contract IntrospectionBase is IIntrospectionBase {\n  function __IntrospectionBase_init() internal {\n    _addInterface(type(IERC165).interfaceId);\n  }\n\n  function _addInterface(bytes4 interfaceId) internal {\n    if (!_supportsInterface(interfaceId)) {\n      IntrospectionStorage.layout().supportedInterfaces[interfaceId] = true;\n    } else {\n      revert Introspection_AlreadySupported();\n    }\n    emit InterfaceAdded(interfaceId);\n  }\n\n  function _removeInterface(bytes4 interfaceId) internal {\n    if (_supportsInterface(interfaceId)) {\n      IntrospectionStorage.layout().supportedInterfaces[interfaceId] = false;\n    } else {\n      revert Introspection_NotSupported();\n    }\n    emit InterfaceRemoved(interfaceId);\n  }\n\n  function _supportsInterface(bytes4 interfaceId) internal view returns (bool) {\n    return IntrospectionStorage.layout().supportedInterfaces[interfaceId];\n  }\n}\n"},"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\ninterface IIntrospectionBase {\n  error Introspection_AlreadySupported();\n  error Introspection_NotSupported();\n\n  /**\n   * @notice Emitted when an interface is added to the contract via `_addInterface`.\n   */\n  event InterfaceAdded(bytes4 indexed interfaceId);\n\n  /**\n   * @notice Emitted when an interface is removed from the contract via `_removeInterface`.\n   */\n  event InterfaceRemoved(bytes4 indexed interfaceId);\n}\n"},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.23;\n\n// interfaces\n\n// libraries\n\n// contracts\n\nlibrary IntrospectionStorage {\n  // keccak256(abi.encode(uint256(keccak256(\"diamond.facets.introspection.storage\")) - 1)) & ~bytes32(uint256(0xff))\n  bytes32 internal constant STORAGE_SLOT =\n    0x81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00;\n\n  struct Layout {\n    mapping(bytes4 => bool) supportedInterfaces;\n  }\n\n  function layout() internal pure returns (Layout storage ds) {\n    bytes32 slot = STORAGE_SLOT;\n    assembly {\n      ds.slot := slot\n    }\n  }\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":4294967295,"enabled":true},"evmVersion":"cancun","remappings":["@openzeppelin/=node_modules/@openzeppelin/","account-abstraction/=node_modules/account-abstraction/contracts/","ds-test/=node_modules/ds-test/src/","forge-std/=node_modules/forge-std/src/","@prb/math/=node_modules/@prb/math/src/","@prb/test/=node_modules/@prb/test/src/","solady/=node_modules/solady/src/","@river-build/diamond/=node_modules/@river-build/diamond/","crypto-lib/=node_modules/crypto-lib/src/","@solidity/=node_modules/crypto-lib/src/","hardhat-deploy/=node_modules/hardhat-deploy/"]}},"stdJsonOutput":{"sources":{"contracts/src/tokens/lock/ILock.sol":{"id":0},"contracts/src/tokens/lock/LockBase.sol":{"id":1},"node_modules/solady/src/auth/Ownable.sol":{"id":19},"node_modules/solady/src/tokens/ERC20.sol":{"id":20},"contracts/src/tokens/lock/LockStorage.sol":{"id":2},"contracts/src/tokens/towns/base/Towns.sol":{"id":6},"contracts/src/tokens/towns/base/ISemver.sol":{"id":5},"contracts/src/tokens/towns/base/IERC7802.sol":{"id":3},"contracts/src/tokens/towns/base/TownsLib.sol":{"id":7},"node_modules/solady/src/tokens/ERC20Votes.sol":{"id":21},"contracts/src/utils/libraries/CustomRevert.sol":{"id":8},"node_modules/solady/src/utils/Initializable.sol":{"id":22},"node_modules/solady/src/utils/UUPSUpgradeable.sol":{"id":23},"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol":{"id":4},"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol":{"id":10},"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":12},"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol":{"id":11},"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol":{"id":9},"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":15},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol":{"id":14},"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":13},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol":{"id":17},"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol":{"id":16},"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol":{"id":18}},"contracts":{"contracts/src/tokens/towns/base/Towns.sol":{"Towns":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"AllowanceOverflow","type":"error","inputs":[]},{"name":"AllowanceUnderflow","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"DelegateeSameAsCurrent","type":"error","inputs":[]},{"name":"ERC5805CheckpointIndexOutOfBounds","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueOverflow","type":"error","inputs":[]},{"name":"ERC5805CheckpointValueUnderflow","type":"error","inputs":[]},{"name":"ERC5805DelegateInvalidSignature","type":"error","inputs":[]},{"name":"ERC5805DelegateSignatureExpired","type":"error","inputs":[]},{"name":"ERC5805FutureLookup","type":"error","inputs":[]},{"name":"InsufficientAllowance","type":"error","inputs":[]},{"name":"InsufficientBalance","type":"error","inputs":[]},{"name":"Introspection_AlreadySupported","type":"error","inputs":[]},{"name":"Introspection_NotSupported","type":"error","inputs":[]},{"name":"InvalidInitialization","type":"error","inputs":[]},{"name":"InvalidPermit","type":"error","inputs":[]},{"name":"LockNotAuthorized","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NotInitializing","type":"error","inputs":[]},{"name":"Permit2AllowanceIsFixedAtInfinity","type":"error","inputs":[]},{"name":"PermitExpired","type":"error","inputs":[]},{"name":"TotalSupplyOverflow","type":"error","inputs":[]},{"name":"TransferLockEnabled","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"UnauthorizedCallContext","type":"error","inputs":[]},{"name":"UpgradeFailed","type":"error","inputs":[]},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CrosschainBurn","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"CrosschainMint","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateChanged","type":"event","inputs":[{"name":"delegator","type":"address","indexed":true,"internalType":"address"},{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"DelegateVotesChanged","type":"event","inputs":[{"name":"delegate","type":"address","indexed":true,"internalType":"address"},{"name":"oldValue","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"newValue","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Initialized","type":"event","inputs":[{"name":"version","type":"uint64","indexed":false,"internalType":"uint64"}],"anonymous":false},{"name":"InterfaceAdded","type":"event","inputs":[{"name":"interfaceId","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"InterfaceRemoved","type":"event","inputs":[{"name":"interfaceId","type":"bytes4","indexed":true,"internalType":"bytes4"}],"anonymous":false},{"name":"LockUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"enabled","type":"bool","indexed":true,"internalType":"bool"},{"name":"expiration","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Upgraded","type":"event","inputs":[{"name":"implementation","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"CLOCK_MODE","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"DOMAIN_SEPARATOR","type":"function","inputs":[],"outputs":[{"name":"result","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"pure"},{"name":"burn","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"checkpointAt","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"i","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"checkpointClock","type":"uint48","internalType":"uint48"},{"name":"checkpointValue","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"checkpointCount","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"clock","type":"function","inputs":[],"outputs":[{"name":"","type":"uint48","internalType":"uint48"}],"stateMutability":"view"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"crosschainBurn","type":"function","inputs":[{"name":"_from","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"crosschainMint","type":"function","inputs":[{"name":"_to","type":"address","internalType":"address"},{"name":"_amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"pure"},{"name":"delegate","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegateBySig","type":"function","inputs":[{"name":"delegatee","type":"address","internalType":"address"},{"name":"nonce","type":"uint256","internalType":"uint256"},{"name":"expiry","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"delegates","type":"function","inputs":[{"name":"delegator","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"getPastVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"},{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getPastVotesTotalSupply","type":"function","inputs":[{"name":"timepoint","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotes","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"getVotesTotalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"initialize","type":"function","inputs":[{"name":"_remoteToken","type":"address","internalType":"address"},{"name":"_owner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"isLockActive","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"l1Token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"l2Bridge","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"pure"},{"name":"lockExpiration","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"nonces","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"permit","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"deadline","type":"uint256","internalType":"uint256"},{"name":"v","type":"uint8","internalType":"uint8"},{"name":"r","type":"bytes32","internalType":"bytes32"},{"name":"s","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"proxiableUUID","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"remoteToken","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"pure"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"upgradeToAndCall","type":"function","inputs":[{"name":"newImplementation","type":"address","internalType":"address"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"payable"},{"name":"version","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.29+commit.ab55807c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AllowanceOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AllowanceUnderflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"DelegateeSameAsCurrent\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointIndexOutOfBounds\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointValueOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805CheckpointValueUnderflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805DelegateInvalidSignature\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805DelegateSignatureExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ERC5805FutureLookup\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientAllowance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Introspection_AlreadySupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Introspection_NotSupported\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidInitialization\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPermit\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"LockNotAuthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewOwnerIsZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoHandoverRequest\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotInitializing\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Permit2AllowanceIsFixedAtInfinity\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"PermitExpired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TotalSupplyOverflow\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferLockEnabled\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnauthorizedCallContext\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UpgradeFailed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"CrosschainBurn\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"CrosschainMint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"delegator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"DelegateChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"delegate\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldValue\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newValue\",\"type\":\"uint256\"}],\"name\":\"DelegateVotesChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"version\",\"type\":\"uint64\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"InterfaceAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"InterfaceRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"bool\",\"name\":\"enabled\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"expiration\",\"type\":\"uint256\"}],\"name\":\"LockUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverCanceled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverRequested\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CLOCK_MODE\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"result\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cancelOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"i\",\"type\":\"uint256\"}],\"name\":\"checkpointAt\",\"outputs\":[{\"internalType\":\"uint48\",\"name\":\"checkpointClock\",\"type\":\"uint48\"},{\"internalType\":\"uint256\",\"name\":\"checkpointValue\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"checkpointCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"clock\",\"outputs\":[{\"internalType\":\"uint48\",\"name\":\"\",\"type\":\"uint48\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"completeOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"crosschainBurn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"crosschainMint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegatee\",\"type\":\"address\"}],\"name\":\"delegate\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegatee\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"expiry\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"delegateBySig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"delegator\",\"type\":\"address\"}],\"name\":\"delegates\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"result\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"timepoint\",\"type\":\"uint256\"}],\"name\":\"getPastVotes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"timepoint\",\"type\":\"uint256\"}],\"name\":\"getPastVotesTotalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"getVotes\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getVotesTotalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_remoteToken\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isLockActive\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l1Token\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2Bridge\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"lockExpiration\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"result\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"ownershipHandoverExpiresAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint8\",\"name\":\"v\",\"type\":\"uint8\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"s\",\"type\":\"bytes32\"}],\"name\":\"permit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"proxiableUUID\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"remoteToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requestOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"AllowanceOverflow()\":[{\"details\":\"The allowance has overflowed.\"}],\"AllowanceUnderflow()\":[{\"details\":\"The allowance has underflowed.\"}],\"AlreadyInitialized()\":[{\"details\":\"Cannot double-initialize.\"}],\"ERC5805CheckpointIndexOutOfBounds()\":[{\"details\":\"Out-of-bounds access for the checkpoints.\"}],\"ERC5805CheckpointValueOverflow()\":[{\"details\":\"Arithmetic overflow when pushing a new checkpoint.\"}],\"ERC5805CheckpointValueUnderflow()\":[{\"details\":\"Arithmetic underflow when pushing a new checkpoint.\"}],\"ERC5805DelegateInvalidSignature()\":[{\"details\":\"The ERC5805 signature to set a delegate is invalid.\"}],\"ERC5805DelegateSignatureExpired()\":[{\"details\":\"The ERC5805 signature to set a delegate has expired.\"}],\"ERC5805FutureLookup()\":[{\"details\":\"The timepoint is in the future.\"}],\"InsufficientAllowance()\":[{\"details\":\"Insufficient allowance.\"}],\"InsufficientBalance()\":[{\"details\":\"Insufficient balance.\"}],\"InvalidInitialization()\":[{\"details\":\"The contract is already initialized.\"}],\"InvalidPermit()\":[{\"details\":\"The permit is invalid.\"}],\"NewOwnerIsZeroAddress()\":[{\"details\":\"The `newOwner` cannot be the zero address.\"}],\"NoHandoverRequest()\":[{\"details\":\"The `pendingOwner` does not have a valid handover request.\"}],\"NotInitializing()\":[{\"details\":\"The contract is not initializing.\"}],\"Permit2AllowanceIsFixedAtInfinity()\":[{\"details\":\"The allowance of Permit2 is fixed at infinity.\"}],\"PermitExpired()\":[{\"details\":\"The permit has expired.\"}],\"TotalSupplyOverflow()\":[{\"details\":\"The total supply has overflowed.\"}],\"Unauthorized()\":[{\"details\":\"The caller is not authorized to call the function.\"}],\"UnauthorizedCallContext()\":[{\"details\":\"The call is from an unauthorized call context.\"}],\"UpgradeFailed()\":[{\"details\":\"The upgrade failed.\"}]},\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when `amount` tokens is approved by `owner` to be used by `spender`.\"},\"CrosschainBurn(address,uint256,address)\":{\"params\":{\"amount\":\"Amount of tokens burned.\",\"from\":\"Address of the account tokens are being burned from.\",\"sender\":\"Address of the account that initiated the crosschain transfer.\"}},\"CrosschainMint(address,uint256,address)\":{\"params\":{\"amount\":\"Amount of tokens minted.\",\"sender\":\"Address of the account that finalized the crosschain transfer.\",\"to\":\"Address of the account tokens are being minted for.\"}},\"DelegateChanged(address,address,address)\":{\"details\":\"The delegate of `delegator` is changed from `from` to `to`.\"},\"DelegateVotesChanged(address,uint256,uint256)\":{\"details\":\"The votes balance of `delegate` is changed from `oldValue` to `newValue`.\"},\"Initialized(uint64)\":{\"details\":\"Triggered when the contract has been initialized.\"},\"LockUpdated(address,bool,uint256)\":{\"params\":{\"account\":\"The account that was updated.\",\"enabled\":\"Whether the lock is enabled.\",\"expiration\":\"The expiration of the lock.\"}},\"OwnershipHandoverCanceled(address)\":{\"details\":\"The ownership handover to `pendingOwner` has been canceled.\"},\"OwnershipHandoverRequested(address)\":{\"details\":\"An ownership handover to `pendingOwner` has been requested.\"},\"OwnershipTransferred(address,address)\":{\"details\":\"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `amount` tokens is transferred from `from` to `to`.\"},\"Upgraded(address)\":{\"details\":\"Emitted when the proxy's implementation is upgraded.\"}},\"kind\":\"dev\",\"methods\":{\"DOMAIN_SEPARATOR()\":{\"details\":\"Returns the EIP-712 domain separator for the EIP-2612 permit.\"},\"allowance(address,address)\":{\"details\":\"Returns the amount of tokens that `spender` can spend on behalf of `owner`.\"},\"approve(address,uint256)\":{\"details\":\"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event.\"},\"balanceOf(address)\":{\"details\":\"Returns the amount of tokens owned by `owner`.\"},\"bridge()\":{\"custom:legacy\":\"@notice Legacy getter for L2_STANDARD_BRIDGE.\"},\"burn(address,uint256)\":{\"params\":{\"amount\":\"Amount of tokens to burn.\",\"from\":\"Address to burn tokens from.\"}},\"cancelOwnershipHandover()\":{\"details\":\"Cancels the two-step ownership handover to the caller, if any.\"},\"checkpointAt(address,uint256)\":{\"details\":\"Returns the voting checkpoint for `account` at index `i`.\"},\"checkpointCount(address)\":{\"details\":\"Returns the number of checkpoints for `account`.\"},\"completeOwnershipHandover(address)\":{\"details\":\"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`.\"},\"crosschainBurn(address,uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to burn.\",\"_from\":\"Address to burn tokens from.\"}},\"crosschainMint(address,uint256)\":{\"params\":{\"_amount\":\"Amount of tokens to mint.\",\"_to\":\"Address to mint tokens to.\"}},\"decimals()\":{\"details\":\"Returns the decimals places of the token.\"},\"delegate(address)\":{\"details\":\"Set the voting delegate of the caller to `delegatee`.\"},\"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)\":{\"details\":\"Sets the voting delegate of the signature signer to `delegatee`.\"},\"delegates(address)\":{\"details\":\"Returns the current voting delegate of `delegator`.\"},\"getPastVotes(address,uint256)\":{\"details\":\"Returns the latest amount of voting units `account` has before or during `timepoint`.\"},\"getPastVotesTotalSupply(uint256)\":{\"details\":\"Returns the latest amount of total voting units before or during `timepoint`.\"},\"getVotes(address)\":{\"details\":\"Returns the latest amount of voting units for `account`.\"},\"getVotesTotalSupply()\":{\"details\":\"Returns the latest amount of total voting units.\"},\"l1Token()\":{\"custom:legacy\":\"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward.\"},\"l2Bridge()\":{\"custom:legacy\":\"@notice Legacy getter for the bridge. Use BRIDGE going forward.\"},\"mint(address,uint256)\":{\"params\":{\"amount\":\"Amount of tokens to mint.\",\"to\":\"Address to mint tokens to.\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"nonces(address)\":{\"details\":\"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit.\"},\"owner()\":{\"details\":\"Returns the owner of the contract.\"},\"ownershipHandoverExpiresAt(address)\":{\"details\":\"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\"},\"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)\":{\"details\":\"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event.\"},\"proxiableUUID()\":{\"details\":\"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract.\"},\"remoteToken()\":{\"custom:legacy\":\"@notice Legacy getter for REMOTE_TOKEN\"},\"renounceOwnership()\":{\"details\":\"Allows the owner to renounce their ownership.\"},\"requestOwnershipHandover()\":{\"details\":\"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default.\"},\"supportsInterface(bytes4)\":{\"details\":\"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token.\"},\"totalSupply()\":{\"details\":\"Returns the amount of tokens in existence.\"},\"transfer(address,uint256)\":{\"details\":\"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event.\"},\"transferOwnership(address)\":{\"details\":\"Allows the owner to transfer the ownership to `newOwner`.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`.\"},\"version()\":{\"custom:semver\":\"1.0.0-beta.12\"}},\"version\":1},\"userdoc\":{\"events\":{\"CrosschainBurn(address,uint256,address)\":{\"notice\":\"Emitted when a crosschain transfer burns tokens.\"},\"CrosschainMint(address,uint256,address)\":{\"notice\":\"Emitted when a crosschain transfer mints tokens.\"},\"InterfaceAdded(bytes4)\":{\"notice\":\"Emitted when an interface is added to the contract via `_addInterface`.\"},\"InterfaceRemoved(bytes4)\":{\"notice\":\"Emitted when an interface is removed from the contract via `_removeInterface`.\"},\"LockUpdated(address,bool,uint256)\":{\"notice\":\"Emitted when the lock is updated.\"}},\"kind\":\"user\",\"methods\":{\"CLOCK_MODE()\":{\"notice\":\"Machine-readable description of the clock as specified in EIP-6372.\"},\"burn(address,uint256)\":{\"notice\":\"Allows the StandardBridge on this network to burn tokens.\"},\"clock()\":{\"notice\":\"Clock used for flagging checkpoints, overridden to implement timestamp based checkpoints (and voting).\"},\"crosschainBurn(address,uint256)\":{\"notice\":\"Allows the SuperchainTokenBridge to burn tokens.\"},\"crosschainMint(address,uint256)\":{\"notice\":\"Allows the SuperchainTokenBridge to mint tokens.\"},\"mint(address,uint256)\":{\"notice\":\"Allows the StandardBridge on this network to mint tokens.\"},\"version()\":{\"notice\":\"Semantic version\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/src/tokens/towns/base/Towns.sol\":\"Towns\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":4294967295},\"remappings\":[\":@openzeppelin/=node_modules/@openzeppelin/\",\":@prb/math/=node_modules/@prb/math/src/\",\":@prb/test/=node_modules/@prb/test/src/\",\":@river-build/diamond/=node_modules/@river-build/diamond/\",\":@solidity/=node_modules/crypto-lib/src/\",\":account-abstraction/=node_modules/account-abstraction/contracts/\",\":crypto-lib/=node_modules/crypto-lib/src/\",\":ds-test/=node_modules/ds-test/src/\",\":forge-std/=node_modules/forge-std/src/\",\":hardhat-deploy/=node_modules/hardhat-deploy/\",\":solady/=node_modules/solady/src/\"]},\"sources\":{\"contracts/src/tokens/lock/ILock.sol\":{\"keccak256\":\"0x1768d1162b79cd091bfa369e057ad1707342ad33855cacb6c823947040673666\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8dc8f9747bf7e9656ec929746feb65dd698c36a336ac751461cf89116dd265e2\",\"dweb:/ipfs/QmewowhYAGxqDDvkExMzdYE9DqyWkwDiF7SS9QPGrgUNL4\"]},\"contracts/src/tokens/lock/LockBase.sol\":{\"keccak256\":\"0x4685389037dfc2a3e039ba397be7030c7e82a092971f3051c6778fa84f438591\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c043ae8d2f7c262adb63eb124efb7fa05f72ae701bb0fd448d94e7eae9ac3dcf\",\"dweb:/ipfs/QmVL1dCW27P2mfqznvnLmKWcKQVFbMg4xadLe1ubiEMDDG\"]},\"contracts/src/tokens/lock/LockStorage.sol\":{\"keccak256\":\"0x80926f5941dd1137653389eec0cf56d51f3dcfdf84bbcd607b1b8b399459789d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6f88d440958ad5a29b02fdf3ac0cdbc43b8c65344faf87d49a6eef4154614a32\",\"dweb:/ipfs/QmUNpHqwqrhP2aepWU6kVM52osMbBUvWGctXSqyjoND6wc\"]},\"contracts/src/tokens/towns/base/IERC7802.sol\":{\"keccak256\":\"0xa386a790ab0cc57bd6c207fd36d2d8b748ddd576ce0bcf41548c20c2073f5d5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://51cd0d5edbfabc1ed79f65c4983fe91809b9fb198ef7a46c7fb6759c8f1f364c\",\"dweb:/ipfs/QmQVMUfz7p5GeD6FFJm795fxsYtfdbYTMzoYF8Df2eSfHC\"]},\"contracts/src/tokens/towns/base/IOptimismMintableERC20.sol\":{\"keccak256\":\"0x8f1c7a7be76ccbaa51e36a604d97d227786c7e12c6be8764e66d14654225d32d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d94b0c58b10424554715d42ad26c41a654268b73d7df3da196672036f17cbd2a\",\"dweb:/ipfs/QmXaBeEytq2WzdkXvp5cbgoW3KAzvjgYqLxEeSvRHwP664\"]},\"contracts/src/tokens/towns/base/ISemver.sol\":{\"keccak256\":\"0x8debf818a0e7f49313d76b22ed9ff03c459553969bc257887963494e1b1fadf6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f033090fc07df64e15bf62bed3bfb03ded05cd7498793c378b8c6342a9a4c794\",\"dweb:/ipfs/QmRCEdKFeNiepYwuZc3pqwQ2ufSiMZD7rzDwS9Du1pSQHz\"]},\"contracts/src/tokens/towns/base/Towns.sol\":{\"keccak256\":\"0xf13e42c72fe06d701b6b944589b26d4de6e3bb81ec5875a15f59646793e226c2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0641368d7ace22db248623382625711aa5d980a6b9de31ddfe92e3f31e6079eb\",\"dweb:/ipfs/QmaBKi4KtVkdwa3o8REr58ZtHfAbHky77jkbZd8zaBS6c7\"]},\"contracts/src/tokens/towns/base/TownsLib.sol\":{\"keccak256\":\"0x03386e26b96a78f2190696bbc84e80d688b368276b01760f88b72bc1e769dcba\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba73bc41da1a110bb513e97241c6de4858e96935b1e5cfeeacf6eb7865ee3620\",\"dweb:/ipfs/QmUjpd63QCKkBZa5ysbwFiL4msHMo4yZnaVCeM9DBHynHy\"]},\"contracts/src/utils/libraries/CustomRevert.sol\":{\"keccak256\":\"0xdf3d131cb19a367b2f2842caffe356e3b6437ff9e82f6519dd3b067630e0a059\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://abaae9b8fa22a7b0f6fe0adafb4ec510f9b720ef281d98b900225c033c66f9b7\",\"dweb:/ipfs/QmNU1NRUCkXibWP7PzNyXvtrkgtpwcUEVP8uFzsWeDmBfK\"]},\"node_modules/@openzeppelin/contracts/governance/utils/IVotes.sol\":{\"keccak256\":\"0x5e2b397ae88fd5c68e4f6762eb9f65f65c36702eb57796495f471d024ce70947\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://348fc8e291d54314bb22437b532f443d5dbfb80c8cc9591567c1af6554ccf856\",\"dweb:/ipfs/QmP8ZTyitZinxcpwAHeYHhwj7u21zPpKXSiww38V74sXC2\"]},\"node_modules/@openzeppelin/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://11fea9f8bc98949ac6709f0c1699db7430d2948137aa94d5a9e95a91f61a710a\",\"dweb:/ipfs/QmQdfRXxQjwP6yn3DVo1GHPpriKNcFghSPi94Z1oKEFUNS\"]},\"node_modules/@openzeppelin/contracts/interfaces/IERC6372.sol\":{\"keccak256\":\"0xeb2857b7dafb7e0d8526dbfe794e6c047df2851c9e6ee91dc4a55f3c34af5d33\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://49bf13f6c2a38a9bcc7b852d4e2b9cebb4068b832642cce61069cdb5f06bb2fb\",\"dweb:/ipfs/QmdKAJVE7rR2kENCZnEM1yKswrGii7WuE9gZpsQvnXJhwn\"]},\"node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://df6f0c459663c9858b6cba2cda1d14a7d05a985bed6d2de72bd8e78c25ee79db\",\"dweb:/ipfs/QmeTTxZ7qVk9rjEv2R4CpCwdf8UMCcRqDNMvzNxHc3Fnn9\"]},\"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c13d13304ac79a83ab1c30168967d19e2203342ebbd6a9bbce4db7550522dcbf\",\"dweb:/ipfs/QmeN5jKMN2vw5bhacr6tkg78afbTTZUeaacNHqjWt4Ew1r\"]},\"node_modules/@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol\":{\"keccak256\":\"0x27dbc90e5136ffe46c04f7596fc2dbcc3acebd8d504da3d93fdb8496e6de04f6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://0ea8b92e4245d75a5579c10f22f118f7b4ba07c57341f181f0b2a85ff8663de3\",\"dweb:/ipfs/Qme3Ss5ByjmkxxkMdLpyu7fQ1PCtjNFH1wEFszt2BZePiG\"]},\"node_modules/@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"node_modules/@river-build/diamond/src/facets/introspection/IIntrospectionBase.sol\":{\"keccak256\":\"0x51e706ab1184a3a5b353b87cfee07d471b9a5ef93897022bbcd1085b39a0c762\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3df386912c5cc759faee161b7825b2014040d04bf06528e74f4d759f06f2eb19\",\"dweb:/ipfs/QmP5AnGGNY4gsV1ABJ3WaueAsAwJVQ229ZfGjGxW8rSbEL\"]},\"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionBase.sol\":{\"keccak256\":\"0x35f27aa0a4b64673a2648110422f31de0c5a71c68df562eccb9c4f2a27ee6647\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2eb1f2ff2e2d7222bf8fe2cf7558a2e47925e3d4557208362b1f50e63cb43006\",\"dweb:/ipfs/QmNcJZSAEPreUy66tt5brPrauVnUb4tqvcxej5Uc4SZZWz\"]},\"node_modules/@river-build/diamond/src/facets/introspection/IntrospectionStorage.sol\":{\"keccak256\":\"0x306f41ef86bc5050a28c1dbf855d3f6f623be4aebc0a0f96474dae85979f7763\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dbad6f8e6685690ae75f6c9066972a45400b45307245feab8990af18a4c38e91\",\"dweb:/ipfs/QmcTUqiSL1z2nwokpNNsXQkjVTaFdFJiM2exguZpPDDXEM\"]},\"node_modules/solady/src/auth/Ownable.sol\":{\"keccak256\":\"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3\",\"dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs\"]},\"node_modules/solady/src/tokens/ERC20.sol\":{\"keccak256\":\"0x5077e979c44badb9f88c24ef9f7991b47ede9d885aeb348a3dc1d38574a9259d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f8a4dd59c08c087de1799ca29223581943d842f44fdbb9aa80647f5cf230e4a2\",\"dweb:/ipfs/QmXBTFix6cZQtH5kA3smuveJFP1xpv7fjWiqWYN8Ny3roV\"]},\"node_modules/solady/src/tokens/ERC20Votes.sol\":{\"keccak256\":\"0x142c47b1e714831fdb1ff88901b3b3bddf26a568c48997fa285203f18d7b91e4\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f4bce951eb0cf10ce1c8e34fd65bdd7b309319f4548c543a0c81afabded7f916\",\"dweb:/ipfs/QmXb7vVpBhNFSuj49srx5oNxJeKEM8mFZgS11Z5Cvvordv\"]},\"node_modules/solady/src/utils/Initializable.sol\":{\"keccak256\":\"0x0873a4cd2510a6f741a3abe8bbb40e6969f45b667431e80247e14ca54f7eb644\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e22e60919b1dc56d62e9e7889174edc7b212cef4cf8686a5e207d324e7b8148f\",\"dweb:/ipfs/QmSjDw5EkCCb8JETqn3YoUXYJ7BYJQex1r9p85zjYY99wu\"]},\"node_modules/solady/src/utils/UUPSUpgradeable.sol\":{\"keccak256\":\"0xed1dbffe8abb226c51288d4fbdedb4da90d50617bfae1cbcc093383a4ec0710a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f41d6e515669bd177befad00fb05a0596ae548a7976e8d39799bd5f9f6329d89\",\"dweb:/ipfs/QmXZMccdm5ZGBjuTHdBH7qZRJV89gdY5ogQFQiqACgaWBv\"]}},\"version\":1}","userdoc":{"kind":"user","events":{"InterfaceAdded(bytes4)":{"notice":"Emitted when an interface is added to the contract via `_addInterface`."},"InterfaceRemoved(bytes4)":{"notice":"Emitted when an interface is removed from the contract via `_removeInterface`."},"LockUpdated(address,bool,uint256)":{"notice":"Emitted when the lock is updated."},"CrosschainBurn(address,uint256,address)":{"notice":"Emitted when a crosschain transfer burns tokens."},"CrosschainMint(address,uint256,address)":{"notice":"Emitted when a crosschain transfer mints tokens."}},"methods":{"clock()":{"notice":"Clock used for flagging checkpoints, overridden to implement timestamp based checkpoints (and voting)."},"version()":{"notice":"Semantic version"},"CLOCK_MODE()":{"notice":"Machine-readable description of the clock as specified in EIP-6372."},"burn(address,uint256)":{"notice":"Allows the StandardBridge on this network to burn tokens."},"mint(address,uint256)":{"notice":"Allows the StandardBridge on this network to mint tokens."},"crosschainBurn(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to burn tokens."},"crosschainMint(address,uint256)":{"notice":"Allows the SuperchainTokenBridge to mint tokens."}},"version":1},"devdoc":{"kind":"dev","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"InvalidPermit()":[{"details":"The permit is invalid."}],"PermitExpired()":[{"details":"The permit has expired."}],"UpgradeFailed()":[{"details":"The upgrade failed."}],"NotInitializing()":[{"details":"The contract is not initializing."}],"AllowanceOverflow()":[{"details":"The allowance has overflowed."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AllowanceUnderflow()":[{"details":"The allowance has underflowed."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"ERC5805FutureLookup()":[{"details":"The timepoint is in the future."}],"InsufficientBalance()":[{"details":"Insufficient balance."}],"TotalSupplyOverflow()":[{"details":"The total supply has overflowed."}],"InsufficientAllowance()":[{"details":"Insufficient allowance."}],"InvalidInitialization()":[{"details":"The contract is already initialized."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"UnauthorizedCallContext()":[{"details":"The call is from an unauthorized call context."}],"ERC5805CheckpointValueOverflow()":[{"details":"Arithmetic overflow when pushing a new checkpoint."}],"ERC5805CheckpointValueUnderflow()":[{"details":"Arithmetic underflow when pushing a new checkpoint."}],"ERC5805DelegateInvalidSignature()":[{"details":"The ERC5805 signature to set a delegate is invalid."}],"ERC5805DelegateSignatureExpired()":[{"details":"The ERC5805 signature to set a delegate has expired."}],"ERC5805CheckpointIndexOutOfBounds()":[{"details":"Out-of-bounds access for the checkpoints."}],"Permit2AllowanceIsFixedAtInfinity()":[{"details":"The allowance of Permit2 is fixed at infinity."}]},"events":{"Upgraded(address)":{"details":"Emitted when the proxy's implementation is upgraded."},"Initialized(uint64)":{"details":"Triggered when the contract has been initialized."},"Approval(address,address,uint256)":{"details":"Emitted when `amount` tokens is approved by `owner` to be used by `spender`."},"LockUpdated(address,bool,uint256)":{"params":{"account":"The account that was updated.","enabled":"Whether the lock is enabled.","expiration":"The expiration of the lock."}},"Transfer(address,address,uint256)":{"details":"Emitted when `amount` tokens is transferred from `from` to `to`."},"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"CrosschainBurn(address,uint256,address)":{"params":{"from":"Address of the account tokens are being burned from.","amount":"Amount of tokens burned.","sender":"Address of the account that initiated the crosschain transfer."}},"CrosschainMint(address,uint256,address)":{"params":{"to":"Address of the account tokens are being minted for.","amount":"Amount of tokens minted.","sender":"Address of the account that finalized the crosschain transfer."}},"DelegateChanged(address,address,address)":{"details":"The delegate of `delegator` is changed from `from` to `to`."},"DelegateVotesChanged(address,uint256,uint256)":{"details":"The votes balance of `delegate` is changed from `oldValue` to `newValue`."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the owner of the contract."},"bridge()":{"custom:legacy":"@notice Legacy getter for L2_STANDARD_BRIDGE."},"symbol()":{"details":"Returns the symbol of the token."},"l1Token()":{"custom:legacy":"@notice Legacy getter for the remote token. Use REMOTE_TOKEN going forward."},"version()":{"custom:semver":"1.0.0-beta.12"},"decimals()":{"details":"Returns the decimals places of the token."},"l2Bridge()":{"custom:legacy":"@notice Legacy getter for the bridge. Use BRIDGE going forward."},"remoteToken()":{"custom:legacy":"@notice Legacy getter for REMOTE_TOKEN"},"totalSupply()":{"details":"Returns the amount of tokens in existence."},"nonces(address)":{"details":"Returns the current nonce for `owner`. This value is used to compute the signature for EIP-2612 permit."},"proxiableUUID()":{"details":"Returns the storage slot used by the implementation, as specified in [ERC1822](https://eips.ethereum.org/EIPS/eip-1822). Note: The `notDelegated` modifier prevents accidental upgrades to an implementation that is a proxy contract."},"delegate(address)":{"details":"Set the voting delegate of the caller to `delegatee`."},"getVotes(address)":{"details":"Returns the latest amount of voting units for `account`."},"DOMAIN_SEPARATOR()":{"details":"Returns the EIP-712 domain separator for the EIP-2612 permit."},"balanceOf(address)":{"details":"Returns the amount of tokens owned by `owner`."},"delegates(address)":{"details":"Returns the current voting delegate of `delegator`."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"burn(address,uint256)":{"params":{"from":"Address to burn tokens from.","amount":"Amount of tokens to burn."}},"getVotesTotalSupply()":{"details":"Returns the latest amount of total voting units."},"mint(address,uint256)":{"params":{"to":"Address to mint tokens to.","amount":"Amount of tokens to mint."}},"approve(address,uint256)":{"details":"Sets `amount` as the allowance of `spender` over the caller's tokens. Emits a {Approval} event."},"checkpointCount(address)":{"details":"Returns the number of checkpoints for `account`."},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."},"transfer(address,uint256)":{"details":"Transfer `amount` tokens from the caller to `to`. Requirements: - `from` must at least have `amount`. Emits a {Transfer} event."},"allowance(address,address)":{"details":"Returns the amount of tokens that `spender` can spend on behalf of `owner`."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"checkpointAt(address,uint256)":{"details":"Returns the voting checkpoint for `account` at index `i`."},"getPastVotes(address,uint256)":{"details":"Returns the latest amount of voting units `account` has before or during `timepoint`."},"crosschainBurn(address,uint256)":{"params":{"_from":"Address to burn tokens from.","_amount":"Amount of tokens to burn."}},"crosschainMint(address,uint256)":{"params":{"_to":"Address to mint tokens to.","_amount":"Amount of tokens to mint."}},"upgradeToAndCall(address,bytes)":{"details":"Upgrades the proxy's implementation to `newImplementation`. Emits a {Upgraded} event. Note: Passing in empty `data` skips the delegatecall to `newImplementation`."},"getPastVotesTotalSupply(uint256)":{"details":"Returns the latest amount of total voting units before or during `timepoint`."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"transferFrom(address,address,uint256)":{"details":"Transfers `amount` tokens from `from` to `to`. Note: Does not update the allowance if it is the maximum uint256 value. Requirements: - `from` must at least have `amount`. - The caller must have at least `amount` of allowance to transfer the tokens of `from`. Emits a {Transfer} event."},"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets the voting delegate of the signature signer to `delegatee`."},"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)":{"details":"Sets `value` as the allowance of `spender` over the tokens of `owner`, authorized by a signed approval by `owner`. Emits a {Approval} event."}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"60a0604052306080523480156012575f5ffd5b506019601d565b6080565b63409feecd1980546001811615603a5763f92ee8a95f526004601cfd5b6001600160401b03808260011c14607b578060011b8355806020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a15b505050565b60805161271a61009f5f395f81816110af0152611193015261271a5ff3fe6080604052600436106102e2575f3560e01c8063715018a611610186578063ae1f6aaf116100dc578063d6c0b2c411610087578063f04e283e11610062578063f04e283e14610993578063f2fde38b146109a6578063fee81cf4146109b9575f5ffd5b8063d6c0b2c4146108ba578063dd62ed3e14610974578063e78cea9214610894575f5ffd5b8063c7a2f1de116100b7578063c7a2f1de14610922578063cd63c4d214610941578063d505accf14610955575f5ffd5b8063ae1f6aaf14610894578063c01e1bd6146108ba578063c3cda52014610903575f5ffd5b80638da5cb5b1161013c5780639ab24eb0116101175780639ab24eb0146108375780639dc29fac14610856578063a9059cbb14610875575f5ffd5b80638da5cb5b1461079d57806391ddadf4146107d057806395d89b41146107f2575f5ffd5b80637ecebe001161016c5780637ecebe00146107105780637f73540c1461074157806384a0e08214610760575f5ffd5b8063715018a6146106d057806376a82342146106d8575f5ffd5b80633a46b1a81161023b57806352d1902d116101f1578063587cde1e116101cc578063587cde1e1461062e5780635c19a95c1461068057806370a082311461069f575f5ffd5b806352d1902d146105cd57806354d1f13d146105e157806354fd4d50146105e9575f5ffd5b8063485cc95511610221578063485cc955146105565780634bf5d7e9146105755780634f1ef286146105ba575f5ffd5b80633a46b1a81461051857806340c10f1914610537575f5ffd5b806323b872dd1161029b5780632b8c49e3116102765780632b8c49e314610414578063313ce567146104335780633644e5151461044e575f5ffd5b806323b872dd146103ce57806325692962146103ed57806328162566146103f5575f5ffd5b8063095ea7b3116102cb578063095ea7b31461036857806318160ddd1461038757806318bf5077146103ad575f5ffd5b806301ffc9a7146102e657806306fdde031461031a575b5f5ffd5b3480156102f1575f5ffd5b50610305610300366004612422565b6109ea565b60405190151581526020015b60405180910390f35b348015610325575f5ffd5b5060408051808201909152600581527f546f776e7300000000000000000000000000000000000000000000000000000060208201525b6040516103119190612461565b348015610373575f5ffd5b506103056103823660046124d7565b610a44565b348015610392575f5ffd5b506805345cdf77eb68f44c545b604051908152602001610311565b3480156103b8575f5ffd5b506103cc6103c73660046124d7565b610ad0565b005b3480156103d9575f5ffd5b506103056103e83660046124ff565b610b70565b6103cc610c55565b348015610400575f5ffd5b5061039f61040f366004612539565b610ca2565b34801561041f575f5ffd5b506103cc61042e3660046124d7565b610ceb565b34801561043e575f5ffd5b5060405160128152602001610311565b348015610459575f5ffd5b50604080518082018252600581527f546f776e7300000000000000000000000000000000000000000000000000000060209182015281517f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f81527fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d1958918101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc69181019190915246606082015230608082015260a0902061039f565b348015610523575f5ffd5b5061039f6105323660046124d7565b610d83565b348015610542575f5ffd5b506103cc6105513660046124d7565b610dc1565b348015610561575f5ffd5b506103cc610570366004612552565b610e13565b348015610580575f5ffd5b5060408051808201909152600e81527f6d6f64653d74696d657374616d70000000000000000000000000000000000000602082015261035b565b6103cc6105c8366004612583565b6110ad565b3480156105d8575f5ffd5b5061039f611190565b6103cc6111ed565b3480156105f4575f5ffd5b5060408051808201909152600d81527f312e302e302d626574612e313200000000000000000000000000000000000000602082015261035b565b348015610639575f5ffd5b5061065b610648366004612539565b63ff466c9f6004525f526018600c205490565b60405173ffffffffffffffffffffffffffffffffffffffff9091168152602001610311565b34801561068b575f5ffd5b506103cc61069a366004612539565b611226565b3480156106aa575f5ffd5b5061039f6106b9366004612539565b6387a211a2600c9081525f91909152602090205490565b6103cc611233565b3480156106e3575f5ffd5b5061039f6106f2366004612539565b63ff466c9f6004525f526017600c205460301c65ffffffffffff1690565b34801561071b575f5ffd5b5061039f61072a366004612539565b6338377508600c9081525f91909152602090205490565b34801561074c575f5ffd5b5061030561075b366004612539565b611246565b34801561076b575f5ffd5b5061077f61077a3660046124d7565b611250565b6040805165ffffffffffff9093168352602083019190915201610311565b3480156107a8575f5ffd5b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275461065b565b3480156107db575f5ffd5b5060405165ffffffffffff42168152602001610311565b3480156107fd575f5ffd5b5060408051808201909152600581527f544f574e53000000000000000000000000000000000000000000000000000000602082015261035b565b348015610842575f5ffd5b5061039f610851366004612539565b6112b1565b348015610861575f5ffd5b506103cc6108703660046124d7565b6112d0565b348015610880575f5ffd5b5061030561088f3660046124d7565b61131e565b34801561089f575f5ffd5b5073420000000000000000000000000000000000001061065b565b3480156108c5575f5ffd5b507f708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b005473ffffffffffffffffffffffffffffffffffffffff1661065b565b34801561090e575f5ffd5b506103cc61091d366004612611565b6113ab565b34801561092d575f5ffd5b5061039f61093c366004612665565b611554565b34801561094c575f5ffd5b5061039f611586565b348015610960575f5ffd5b506103cc61096f36600461267c565b6115a5565b34801561097f575f5ffd5b5061039f61098e366004612552565b6117bb565b6103cc6109a1366004612539565b61183b565b6103cc6109b4366004612539565b611875565b3480156109c4575f5ffd5b5061039f6109d3366004612539565b63389a75e1600c9081525f91909152602090205490565b7fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00602052604081205460ff165b92915050565b5f73ffffffffffffffffffffffffffffffffffffffff83166e22d473030f116ddee9f6b43ac78ba31882191517610a8257633f68539a5f526004601cfd5b82602052637f5e9f20600c52335f52816034600c2055815f52602c5160601c337f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560205fa350600192915050565b3373420000000000000000000000000000000000002814610b1457610b147f82b429000000000000000000000000000000000000000000000000000000000061189b565b610b1e82826118a3565b604051818152339073ffffffffffffffffffffffffffffffffffffffff8416907fde22baff038e3a3e08407cbdf617deed74e869a7ba517df611e33131c6e6ea04906020015b60405180910390a35050565b5f610b7c848484611931565b8360601b6e22d473030f116ddee9f6b43ac78ba33314610bd05733602052637f5e9f208117600c526034600c208054801915610bcd5780851115610bc7576313be252b5f526004601cfd5b84810382555b50505b6387a211a28117600c526020600c20805480851115610bf65763f4d678b85f526004601cfd5b84810382555050835f526020600c208381540181555082602052600c5160601c8160601c7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a350610c4b848484611988565b5060019392505050565b5f6202a30067ffffffffffffffff164201905063389a75e1600c52335f52806020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f5fa250565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c36020526040812054610a3e565b3373420000000000000000000000000000000000002814610d2f57610d2f7f82b429000000000000000000000000000000000000000000000000000000000061189b565b610d398282611993565b604051818152339073ffffffffffffffffffffffffffffffffffffffff8416907fb90795a66650155983e242cac3e1ac1a4dc26f8ed2987f3ce416a34e00111fd490602001610b64565b5f4265ffffffffffff168210610d9b57610d9b611a26565b610dba610db48463ff466c9f6004525f526017600c2090565b83611a33565b9392505050565b3373420000000000000000000000000000000000001014610e0557610e057f82b429000000000000000000000000000000000000000000000000000000000061189b565b610e0f82826118a3565b5050565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffbf6011328054600382558015610e645760018160011c14303b10610e5b5763f92ee8a95f526004601cfd5b818160ff1b1b91505b50610e6e82611b01565b7f708ba15393f53e4db9d749d00ba2ba89a43d1e182bc44eaf801b83b223310b0080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff8516179055610ed962278d00611b64565b610f027f36372b0700000000000000000000000000000000000000000000000000000000611b8c565b610f2b7fa219a02500000000000000000000000000000000000000000000000000000000611b8c565b610f547f9d8ff7da00000000000000000000000000000000000000000000000000000000611b8c565b610f7d7fda287a1d00000000000000000000000000000000000000000000000000000000611b8c565b610fa67f01ffc9a700000000000000000000000000000000000000000000000000000000611b8c565b610fcf7fe90fb3f600000000000000000000000000000000000000000000000000000000611b8c565b610ff87fec4fc8e300000000000000000000000000000000000000000000000000000000611b8c565b6110217f1d1d8b6300000000000000000000000000000000000000000000000000000000611b8c565b61104a7f54fd4d5000000000000000000000000000000000000000000000000000000000611b8c565b6110737f3333199400000000000000000000000000000000000000000000000000000000611b8c565b80156110a8576002815560016020527fc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2602080a15b505050565b7f00000000000000000000000000000000000000000000000000000000000000003081036110e257639f03a0265f526004601cfd5b6110eb84611ce1565b8360601b60601c93503d5f526352d1902d6001527f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc80602060016004601d895afa5114611140576355299b496001526004601dfd5b847fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b5f38a2849055811561118a57604051828482375f388483885af4611188573d5f823e3d81fd5b505b50505050565b5f7f00000000000000000000000000000000000000000000000000000000000000003081146111c657639f03a0265f526004601cfd5b7f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc91505090565b63389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f5fa2565b6112303382611ce9565b50565b61123b611d80565b6112445f611db5565b565b5f610a3e82611e1a565b5f5f5f6112698563ff466c9f6004525f526017600c2090565b9050805460a01b60d01c8410611286576386df9d105f526004601cfd5b8381015465ffffffffffff8116935060601c91503082036112a957808401195491505b509250929050565b5f610a3e6112cb8363ff466c9f6004525f526017600c2090565b611ec0565b3373420000000000000000000000000000000000001014611314576113147f82b429000000000000000000000000000000000000000000000000000000000061189b565b610e0f8282611993565b5f61132a338484611931565b6387a211a2600c52335f526020600c208054808411156113515763f4d678b85f526004601cfd5b83810382555050825f526020600c208281540181555081602052600c5160601c337fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a36113a2338484611988565b50600192915050565b60408051808201909152600581527f546f776e730000000000000000000000000000000000000000000000000000006020909101525f7fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d19587fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc64287101561143857633480e9e15f526004601cfd5b6040517fe48329057bfd03d55e49b547132e39cffd9c1820ad7b9d4c5307691425d15adf5f528960601b60601c602052886040528760605260805f206040526119015f527f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f815282602082015281604082015246606082015230608082015260a081206020526042601e205f528660ff1660205285604052846060526020600160805f60015afa51935080604052505f6060523d159650868861150c856338377508600c9081525f91909152602090205490565b18171561152057631838d95c5f526004601cfd5b61153f836338377508600c52805f526020600c20805460010181555050565b611549838a611ce9565b505050505050505050565b5f4265ffffffffffff16821061156c5761156c611a26565b610a3e6fff466c9f00000000000000000000000083611a33565b5f6115a06fff466c9f000000000000000000000000611ec0565b905090565b73ffffffffffffffffffffffffffffffffffffffff86166e22d473030f116ddee9f6b43ac78ba318851915176115e257633f68539a5f526004601cfd5b60408051808201909152600581527f546f776e730000000000000000000000000000000000000000000000000000006020909101527fa40fbb70ec34ea8f6c23cf82b55213860ae24ffafadff8e9ae4cb556f54d19587fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc64286101561166e57631a15a3cc5f526004601cfd5b6040518960601b60601c99508860601b60601c985065383775081901600e52895f526020600c2080547f8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f835284602084015283604084015246606084015230608084015260a08320602e527f6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c983528b60208401528a60408401528960608401528060808401528860a084015260c08320604e526042602c205f528760ff16602052866040528560605260208060805f60015afa8c3d51146117565763ddafbaef5f526004601cfd5b019055777f5e9f20000000000000000000000000000000000000000089176040526034602c20889055888a7f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925602060608501a360405250505f60605250505050505050565b5f7fffffffffffffffffffffffffffffffffffdd2b8cfcf0ee922116094bc538745d73ffffffffffffffffffffffffffffffffffffffff83160161182057507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff610a3e565b50602052637f5e9f20600c9081525f91909152603490205490565b611843611d80565b63389a75e1600c52805f526020600c20805442111561186957636f5e88185f526004601cfd5b5f905561123081611db5565b61187d611d80565b8060601b61189257637448fbae5f526004601cfd5b61123081611db5565b805f5260045ffd5b6118ae5f8383611931565b6805345cdf77eb68f44c54818101818110156118d15763e5cfe9575f526004601cfd5b806805345cdf77eb68f44c5550506387a211a2600c52815f526020600c208181540181555080602052600c5160601c5f7fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602080a3610e0f5f8383611988565b73ffffffffffffffffffffffffffffffffffffffff83161580159061195a575061195a83611e1a565b156110a8576110a87f55c421950000000000000000000000000000000000000000000000000000000061189b565b6110a8838383611f0a565b61199e825f83611931565b6387a211a2600c52815f526020600c208054808311156119c55763f4d678b85f526004601cfd5b82900390556805345cdf77eb68f44c805482900390555f81815273ffffffffffffffffffffffffffffffffffffffff83167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef602083a3610e0f825f83611988565b63f98744645f526004601cfd5b5f5f835460a01b60d01c60068110611aa757601061ffff821160041b82811c60ff1060031b17600190811c9190911b80830401811c80830401811c80830401811c80830401811c80830401811c80830401901c81038581015465ffffffffffff168510611aa4576001019150611aa7565b90505b5b80821015611ad95780820160011c65ffffffffffff86820154168510611ad2576001019150611aa8565b9050611aa8565b8460018203019150815460601c81151502925050308203611afa5780195491505b5092915050565b73ffffffffffffffffffffffffffffffffffffffff167fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927819055805f7f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08180a350565b611230817ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c155565b7fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b00602052604090205460ff16611c60577fffffffff0000000000000000000000000000000000000000000000000000000081165f9081527f81088bbc801e045ea3e7620779ab349988f58afbdfba10dff983df3f33522b006020526040902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00166001179055611c92565b6040517ff2cfeefa00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6040517fffffffff000000000000000000000000000000000000000000000000000000008216907f78f84e5b1c5c05be2b5ad3800781dd404d6d6c6302bc755c0fe20f58a33a7f22905f90a250565b611230611d80565b63ff466c9f6004525f8290526018600c205473ffffffffffffffffffffffffffffffffffffffff80831690821603611d4457611d447f09ca3c9c0000000000000000000000000000000000000000000000000000000061189b565b73ffffffffffffffffffffffffffffffffffffffff8216611d6d57611d6883611fc6565b611d76565b611d7683612089565b6110a88383612177565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927543314611244576382b429005f526004601cfd5b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927805473ffffffffffffffffffffffffffffffffffffffff9092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a355565b73ffffffffffffffffffffffffffffffffffffffff81165f9081527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c260205260408120547ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c19060ff1615611e915750600192915050565b73ffffffffffffffffffffffffffffffffffffffff9092165f9081526002909201602052506040902054421090565b5f815460a01b60d01c90508015611f0557017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01805460601c308103611f0557508019545b919050565b73ffffffffffffffffffffffffffffffffffffffff8316611f4d57611f4a6fff466c9f0000000000000000000000004265ffffffffffff168360016121d7565b50505b73ffffffffffffffffffffffffffffffffffffffff8216611f8f57611f8c6fff466c9f0000000000000000000000004265ffffffffffff16835f6121d7565b50505b6110a8611fa98463ff466c9f6004525f526018600c205490565b611fc08463ff466c9f6004525f526018600c205490565b83612305565b7ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c180545f90611ff590426126e2565b73ffffffffffffffffffffffffffffffffffffffff84165f818152600185016020908152604080832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001690556002870182528083208590555184815293945090927fe16066c96aababa72475f0b2768d3b6181ea150033042b37d0646737caa4a501910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff81165f8181527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c26020908152604080832080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660019081179091557ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c3835281842084905590519283527ffd180fd2eec04a0893e9c9ad4329d2f65f17d7fd0b4133b91663887d04d247c193909290917fe16066c96aababa72475f0b2768d3b6181ea150033042b37d0646737caa4a5019101610b64565b5f8160601b60601c63ff466c9f600452835f526018600c2080549250818155508082600c5160601c7f3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f5f5fa4506110a881836121d286612409565b612305565b5f5f85548060a01b60d01c8061223d57851585176121fc57635915f6865f526004601cfd5b8592508260a01c3084141761222257606083901b871766010000000000001788556122fa565b3060601b8717660100000000000017885587198390556122fa565b87600182030180548060601c95503086036122585781195495505b866122775787860394508585111561229157635915f6865f526004601cfd5b87860194508585101561229157639dbbeb755f526004601cfd5b65ffffffffffff168881146122b857660100000000000084018a5560019283019291909101905b8260301c89821117156122c757fe5b508360a01c308514176122e7578360601b8260301b8917178155506122fa565b3060601b8260301b891717815583811955505b505094509492505050565b8061230f57505050565b73ffffffffffffffffffffffffffffffffffffffff808416908316808203612338575050505050565b811561239d575f5f6123696123598863ff466c9f6004525f526017600c2090565b4265ffffffffffff16875f6121d7565b91509150815f5280602052837fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72460405fa250505b8015611188575f5f6123cf6123be8763ff466c9f6004525f526017600c2090565b4265ffffffffffff168760016121d7565b91509150815f5280602052827fdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a72460405fa250505050505050565b6387a211a2600c9081525f828152602090912054610a3e565b5f60208284031215612432575f5ffd5b81357fffffffff0000000000000000000000000000000000000000000000000000000081168114610dba575f5ffd5b602081525f82518060208401528060208501604085015e5f6040828501015260407fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f83011684010191505092915050565b803573ffffffffffffffffffffffffffffffffffffffff81168114611f05575f5ffd5b5f5f604083850312156124e8575f5ffd5b6124f1836124b4565b946020939093013593505050565b5f5f5f60608486031215612511575f5ffd5b61251a846124b4565b9250612528602085016124b4565b929592945050506040919091013590565b5f60208284031215612549575f5ffd5b610dba826124b4565b5f5f60408385031215612563575f5ffd5b61256c836124b4565b915061257a602084016124b4565b90509250929050565b5f5f5f60408486031215612595575f5ffd5b61259e846124b4565b9250602084013567ffffffffffffffff8111156125b9575f5ffd5b8401601f810186136125c9575f5ffd5b803567ffffffffffffffff8111156125df575f5ffd5b8660208284010111156125f0575f5ffd5b939660209190910195509293505050565b803560ff81168114611f05575f5ffd5b5f5f5f5f5f5f60c08789031215612626575f5ffd5b61262f876124b4565b9550602087013594506040870135935061264b60608801612601565b9598949750929560808101359460a0909101359350915050565b5f60208284031215612675575f5ffd5b5035919050565b5f5f5f5f5f5f5f60e0888a031215612692575f5ffd5b61269b886124b4565b96506126a9602089016124b4565b955060408801359450606088013593506126c560808901612601565b9699959850939692959460a0840135945060c09093013592915050565b80820180821115610a3e577f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd","sourceMap":"1376:9469:6:-:0;;;1525:4:23;1466:66;;3440:47:6;;;;;;;;;-1:-1:-1;3460:22:6;:20;:22::i;:::-;1376:9469;;7118:736:22;-1:-1:-1;;7294:8:22;;7325:1;7318:9;;7315:134;;;7359:10;7353:4;7346:24;7430:4;7424;7417:18;7315:134;-1:-1:-1;;;;;7534:9:22;7530:1;7527;7523:9;7520:24;7510:328;;7662:9;7659:1;7655:17;7652:1;7645:28;7752:9;7746:4;7739:23;7796:27;7790:4;7784;7779:45;7510:328;;;7271:577;7118:736::o;1376:9469:6:-;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1376:9469:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6757:148;;;;;;;;;;-1:-1:-1;6757:148:6;;;;;:::i;:::-;;:::i;:::-;;;516:14:24;;509:22;491:41;;479:2;464:18;6757:148:6;;;;;;;;7720:83;;;;;;;;;;-1:-1:-1;7794:4:6;;;;;;;;;;;;;;;;;7720:83;;;;;;;:::i;8175:1029:20:-;;;;;;;;;;-1:-1:-1;8175:1029:20;;;;;:::i;:::-;;:::i;6907:195::-;;;;;;;;;;-1:-1:-1;7067:18:20;7061:25;6907:195;;;1677:25:24;;;1665:2;1650:18;6907:195:20;1531:177:24;5922:179:6;;;;;;;;;;-1:-1:-1;5922:179:6;;;;;:::i;:::-;;:::i;:::-;;11165:4753:20;;;;;;;;;;-1:-1:-1;11165:4753:20;;;;;:::i;:::-;;:::i;9021:617:19:-;;;:::i;7308:131:6:-;;;;;;;;;;-1:-1:-1;7308:131:6;;;;;:::i;:::-;;:::i;6265:185::-;;;;;;;;;;-1:-1:-1;6265:185:6;;;;;:::i;:::-;;:::i;7898:77::-;;;;;;;;;;-1:-1:-1;7898:77:6;;7968:2;2425:36:24;;2413:2;2398:18;7898:77:6;2283:184:24;21458:737:20;;;;;;;;;;-1:-1:-1;2419:4:6;;;;;;;;;;;;;;;;;21877:11:20;;21944:16;21934:27;;2403:22:6;21981:12:20;;;21974:30;;;;5177:66;22024:12;;;22017:33;;;;22084:9;22077:4;22070:12;;22063:31;22128:9;22121:4;22114:12;;22107:31;22174:4;22161:18;;21458:737;;5912:294:21;;;;;;;;;;-1:-1:-1;5912:294:21;;;;;:::i;:::-;;:::i;8144:145:6:-;;;;;;;;;;-1:-1:-1;8144:145:6;;;;;:::i;:::-;;:::i;3491:806::-;;;;;;;;;;-1:-1:-1;3491:806:6;;;;;:::i;:::-;;:::i;8920:101::-;;;;;;;;;;-1:-1:-1;8993:23:6;;;;;;;;;;;;;;;;;8920:101;;4017:1618:23;;;;;;:::i;:::-;;:::i;3584:227::-;;;;;;;;;;;;;:::i;9720:456:19:-;;;:::i;4367:98:6:-;;;;;;;;;;-1:-1:-1;4438:22:6;;;;;;;;;;;;;;;;;4367:98;;6277:305:21;;;;;;;;;;-1:-1:-1;6277:305:21;;;;;:::i;:::-;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;;;;3760:42:24;3748:55;;;3730:74;;3718:2;3703:18;6277:305:21;3584:226:24;6655:101:21;;;;;;;;;;-1:-1:-1;6655:101:21;;;;;:::i;:::-;;:::i;7168:286:20:-;;;;;;;;;;-1:-1:-1;7168:286:20;;;;;:::i;:::-;7336:18;7330:4;7323:32;;;7231:14;7368:19;;;;7432:4;7416:21;;7410:28;;7168:286;8762:100:19;;;:::i;9456:274:21:-;;;;;;;;;;-1:-1:-1;9456:274:21;;;;;:::i;:::-;15244:29;15238:4;15231:43;9527:14;15287:21;15347:4;15341;15331:21;9699:13;9681:33;;;;;9456:274;17137:340:20;;;;;;;;;;-1:-1:-1;17137:340:20;;;;;:::i;:::-;17360:17;17354:4;17347:31;;;17197:14;17391:19;;;;17455:4;17439:21;;17433:28;;17137:340;7188:116:6;;;;;;;;;;-1:-1:-1;7188:116:6;;;;;:::i;:::-;;:::i;9807:797:21:-;;;;;;;;;;-1:-1:-1;9807:797:21;;;;;:::i;:::-;;:::i;:::-;;;;4017:14:24;4005:27;;;3987:46;;4064:2;4049:18;;4042:34;;;;3960:18;9807:797:21;3815:267:24;11408:182:19;;;;;;;;;;-1:-1:-1;11562:11:19;11556:18;11408:182;;8738:96:6;;;;;;;;;;-1:-1:-1;8738:96:6;;4261:14:24;8813:15:6;4249:27:24;4231:46;;4219:2;4204:18;8738:96:6;4087:196:24;7807:87:6;;;;;;;;;;-1:-1:-1;7883:6:6;;;;;;;;;;;;;;;;;7807:87;;5658:149:21;;;;;;;;;;-1:-1:-1;5658:149:21;;;;;:::i;:::-;;:::i;8462::6:-;;;;;;;;;;-1:-1:-1;8462:149:6;;;;;:::i;:::-;;:::i;9391:1406:20:-;;;;;;;;;;-1:-1:-1;9391:1406:20;;;;;:::i;:::-;;:::i;5042:97:6:-;;;;;;;;;;-1:-1:-1;206:42:7;5042:97:6;;4849:98;;;;;;;;;;-1:-1:-1;769:12:7;4913:29:6;;;4849:98;;6840:2265:21;;;;;;;;;;-1:-1:-1;6840:2265:21;;;;;:::i;:::-;;:::i;10916:254::-;;;;;;;;;;-1:-1:-1;10916:254:21;;;;;:::i;:::-;;:::i;10672:147::-;;;;;;;;;;;;;:::i;17661:3716:20:-;;;;;;;;;;-1:-1:-1;17661:3716:20;;;;;:::i;:::-;;:::i;7549:495::-;;;;;;;;;;-1:-1:-1;7549:495:20;;;;;:::i;:::-;;:::i;10363:708:19:-;;;;;;:::i;:::-;;:::i;8348:349::-;;;;;;:::i;:::-;;:::i;11693:435::-;;;;;;;;;;-1:-1:-1;11693:435:19;;;;;:::i;:::-;11963:19;11957:4;11950:33;;;11812:14;11996:26;;;;12106:4;12090:21;;12084:28;;11693:435;6757:148:6;1119:62:17;;;6850:4:6;1119:62:17;;;296:66:18;1119:62:17;;;;;;;;6869:31:6;6862:38;6757:148;-1:-1:-1;;6757:148:6:o;8175:1029:20:-;8249:4;8483:25;;;8510:8;8479:40;8528:11;;8521:19;8476:65;8466:222;;8578:10;8572:4;8565:24;8665:4;8659;8652:18;8466:222;8864:7;8858:4;8851:21;8898:20;8892:4;8885:34;8945:8;8939:4;8932:22;8997:6;8990:4;8984;8974:21;8967:37;9072:6;9066:4;9059:20;9160:4;9154:11;9150:2;9146:20;9136:8;9109:25;9103:4;9097;9092:75;-1:-1:-1;9193:4:20;8175:1029;;;;:::o;5922:179:6:-;3039:10;371:42:7;3039:46:6;3035:113;;3095:46;3119:21;3095:23;:46::i;:::-;6026:19:::1;6032:3;6037:7;6026:5;:19::i;:::-;6056:40;::::0;1677:25:24;;;6085:10:6::1;::::0;6056:40:::1;::::0;::::1;::::0;::::1;::::0;1665:2:24;1650:18;6056:40:6::1;;;;;;;;5922:179:::0;;:::o;11165:4753:20:-;11253:4;11269:38;11290:4;11296:2;11300:6;11269:20;:38::i;:::-;11533:4;11529:2;11525:13;11578:8;11568;11565:22;11555:928;;11694:8;11688:4;11681:22;11747:20;11740:5;11737:31;11731:4;11724:45;11827:4;11821;11811:21;11877:13;11871:20;11993:10;11989:15;11986:479;;;12134:10;12126:6;12123:22;12120:183;;;12189:10;12183:4;12176:24;12272:4;12266;12259:18;12120:183;12435:6;12423:10;12419:23;12404:13;12397:46;11986:479;;;11555:928;12587:18;12580:5;12577:29;12571:4;12564:43;12663:4;12657;12647:21;12710:15;12704:22;12808:11;12800:6;12797:23;12794:158;;;12856:10;12850:4;12843:24;12929:4;12923;12916:18;12794:158;13069:6;13056:11;13052:24;13035:15;13028:49;;;13160:2;13154:4;13147:16;13217:4;13211;13201:21;13483:6;13467:13;13461:20;13457:33;13442:13;13435:56;;13567:6;13561:4;13554:20;13665:4;13659:11;13655:2;13651:20;13643:5;13639:2;13635:14;13608:25;13602:4;13596;13591:81;;15853:37;15873:4;15879:2;15883:6;15853:19;:37::i;:::-;-1:-1:-1;15907:4:20;11165:4753;;;;;:::o;9021:617:19:-;9114:15;7972:9;9132:46;;:15;:46;9114:64;;9346:19;9340:4;9333:33;9396:8;9390:4;9383:22;9452:7;9445:4;9439;9429:21;9422:38;9599:8;9552:45;9549:1;9546;9541:67;9248:374;9021:617::o;7308:131:6:-;1508:49:1;;;7388:7:6;1508:49:1;;;:40;:49;;;;;;7410:24:6;1421:141:1;6265:185:6;3039:10;371:42:7;3039:46:6;3035:113;;3095:46;3119:21;3095:23;:46::i;:::-;6371:21:::1;6377:5;6384:7;6371:5;:21::i;:::-;6403:42;::::0;1677:25:24;;;6434:10:6::1;::::0;6403:42:::1;::::0;::::1;::::0;::::1;::::0;1665:2:24;1650:18;6403:42:6::1;1531:177:24::0;5912:294:21;6031:7;8813:15:6;6058:20:21;;:9;:20;6054:54;;6080:28;:26;:28::i;:::-;6125:74;6154:33;6179:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;6154:33;6189:9;6125:28;:74::i;:::-;6118:81;5912:294;-1:-1:-1;;;5912:294:21:o;8144:145:6:-;2810:10;206:42:7;2810:41:6;2806:108;;2861:46;2885:21;2861:23;:46::i;:::-;8267:17:::1;8273:2;8277:6;8267:5;:17::i;:::-;8144:145:::0;;:::o;3491:806::-;2001:66:22;3768:8;;3866:1;3856:12;;3950:398;;;;4110:1;4106;4103;4099:9;4096:16;4084:9;4072:22;4069:44;4059:189;;4150:10;4144:4;4137:24;4225:4;4219;4212:18;4059:189;4287:1;4283;4278:3;4274:11;4270:19;4265:24;;3950:398;;3609:24:6::1;3626:6;3609:16;:24::i;:::-;769:12:7::0;896:28;;;;;;;;;;3746:24:6::1;3762:7;3746:15;:24::i;:::-;3798:39;3812:24;3798:13;:39::i;:::-;3843:47;3857:32;3843:13;:47::i;:::-;3896:45;3910:30;3896:13;:45::i;:::-;3947:41;3961:26;3947:13;:41::i;:::-;3994:40;4008:25;3994:13;:40::i;:::-;4040:39;4054:24;4040:13;:39::i;:::-;4085:55;4099:40;4085:13;:55::i;:::-;4146:53;4160:38;4146:13;:53::i;:::-;4205:40;4219:25;4205:13;:40::i;:::-;4251:41;4265:26;4251:13;:41::i;:::-;4447:1:22::0;4444:263;;;4548:1;4545;4538:12;4629:1;4623:4;4616:15;4665:27;4659:4;4653;4648:45;4444:263;4430:287;3491:806:6;;:::o;4017:1618:23:-;5755:6;6116:9;6110:16;;6107:143;;6158:10;6152:4;6145:24;6231:4;6225;6218:18;6107:143;4170:36:::1;4188:17;4170;:36::i;:::-;4319:17;4315:2;4311:26;4307:2;4303:35;4282:56;;4389:16;4383:4;4376:30;4432:10;4426:4;4419:24;4487:28;4692:1;4684:4;4678;4672;4666;4647:17;4640:5;4629:60;4623:67;4620:74;4610:199;;4727:10;4721:4;4714:24;4790:4;4784;4777:18;4610:199;4914:17;4887:25;4881:4;4869:10;4864:68;4945:28:::0;;;5103:516;::::1;;;5231:4;5225:11;5282;5269;5266:1;5253:41;5388:4;5376:10;5363:11;5360:1;5341:17;5334:5;5321:72;5311:294;;5522:16;5516:4;5513:1;5498:41;5570:16;5567:1;5560:27;5311:294;;5103:516;5733:544:::0;4017:1618;;;:::o;3584:227::-;3651:7;6450:6;6548:9;6542:16;;6532:151;;6591:10;6585:4;6578:24;6664:4;6658;6651:18;6532:151;2619:66:::1;::::0;-1:-1:-1;6428:282:23;3584:227;:::o;9720:456:19:-;9922:19;9916:4;9909:33;9968:8;9962:4;9955:22;10020:1;10013:4;10007;9997:21;9990:32;10151:8;10105:44;10102:1;10099;10094:66;9720:456::o;6655:101:21:-;6717:32;6727:10;6739:9;6717;:32::i;:::-;6655:101;:::o;8762:100:19:-;12517:13;:11;:13::i;:::-;8834:21:::1;8852:1;8834:9;:21::i;:::-;8762:100::o:0;7188:116:6:-;7258:4;7277:22;7291:7;7277:13;:22::i;9807:797:21:-;9918:22;9942:23;9981:18;10002:33;10027:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;10002:33;9981:54;;10151:10;10145:17;10140:3;10136:27;10131:3;10127:37;10124:1;10121:44;10111:189;;10198:10;10192:4;10185:24;10281:4;10275;10268:18;10111:189;10343:18;;;10337:25;10398:14;10394:37;;;-1:-1:-1;10467:2:21;10463:25;;-1:-1:-1;10524:9:21;10504:30;;10501:87;;10573:10;10570:1;10566:18;10562:23;10556:30;10537:49;;10501:87;10097:501;9807:797;;;;;:::o;5658:149::-;5722:7;5748:52;5766:33;5791:7;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;5766:33;5748:17;:52::i;8462:149:6:-;2810:10;206:42:7;2810:41:6;2806:108;;2861:46;2885:21;2861:23;:46::i;:::-;8587:19:::1;8593:4;8599:6;8587:5;:19::i;9391:1406:20:-:0;9461:4;9477:44;9498:10;9510:2;9514:6;9477:20;:44::i;:::-;9670:18;9664:4;9657:32;9715:8;9709:4;9702:22;9776:4;9770;9760:21;9819:15;9813:22;9909:11;9901:6;9898:23;9895:146;;;9953:10;9947:4;9940:24;10022:4;10016;10009:18;9895:146;10150:6;10137:11;10133:24;10116:15;10109:49;;;10233:2;10227:4;10220:16;10286:4;10280;10270:21;10536:6;10520:13;10514:20;10510:33;10495:13;10488:56;;10612:6;10606:4;10599:20;10700:4;10694:11;10690:2;10686:20;10676:8;10649:25;10643:4;10637;10632:75;10726:43;10746:10;10758:2;10762:6;10726:19;:43::i;:::-;-1:-1:-1;10786:4:20;9391:1406;;;;:::o;6840:2265:21:-;2419:4:6;;;;;;;;;;;;;;;;;;-1:-1:-1;2403:22:6;5177:66:20;7380:11:21;7377:23;-1:-1:-1;7374:158:21;;;7432:10;7426:4;7419:24;7513:4;7507;7500:18;7374:158;7560:4;7554:11;7631:28;7625:4;7618:42;7702:9;7698:2;7694:18;7690:2;7686:27;7680:4;7673:41;7740:5;7734:4;7727:19;7772:6;7766:4;7759:20;7821:4;7815;7805:21;7799:4;7792:35;7853:6;7847:4;7840:20;7949:16;7946:1;7939:27;8000:8;7993:4;7990:1;7986:12;7979:30;8043:11;8036:4;8033:1;8029:12;8022:33;8089:9;8082:4;8079:1;8075:12;8068:31;8133:9;8126:4;8123:1;8119:12;8112:31;8182:4;8179:1;8169:18;8163:4;8156:32;8277:4;8271;8261:21;8255:4;8248:35;8319:1;8313:4;8309:12;8303:4;8296:26;8348:1;8342:4;8335:15;8376:1;8370:4;8363:15;8446:4;8440;8434;8428;8425:1;8418:5;8407:44;8401:51;8391:61;;8478:1;8472:4;8465:15;;8542:1;8536:4;8529:15;8688:16;8681:24;8671:34;;8804:6;8795:5;8778:14;8785:6;17360:17:20;17354:4;17347:31;;;17197:14;17391:19;;;;17455:4;17439:21;;17433:28;;17137:340;8778:14:21;:22;8777:33;:38;8773:255;;8918:10;8912:4;8905:24;8999:4;8993;8986:18;8773:255;9037:23;9053:6;16833:17:20;16827:4;16820:31;16877:5;16871:4;16864:19;16929:4;16923;16913:21;16978:9;16972:16;16969:1;16965:24;16954:9;16947:43;;16687:319;;9037:23:21;9070:28;9080:6;9088:9;9070;:28::i;:::-;7013:2092;;;6840:2265;;;;;;:::o;10916:254::-;10997:7;8813:15:6;11020:20:21;;:9;:20;11016:54;;11042:28;:26;:28::i;:::-;11087:76;11116:35;11153:9;11087:28;:76::i;10672:147::-;10732:7;10758:54;10776:35;10758:17;:54::i;:::-;10751:61;;10672:147;:::o;17661:3716:20:-;18077:25;;;18104:8;18073:40;18122:10;;18115:18;18070:64;18060:221;;18171:10;18165:4;18158:24;18258:4;18252;18245:18;18060:221;2419:4:6;;;;;;;;;;;;;;;;;;2403:22;5177:66:20;18720:11;18717:25;-1:-1:-1;18714:142:20;;;18774:10;18768:4;18761:24;18837:4;18831;18824:18;18714:142;18884:4;18878:11;19000:5;18996:2;18992:14;18988:2;18984:23;18975:32;;19047:7;19043:2;19039:16;19035:2;19031:25;19020:36;;19140:39;19134:4;19127:53;19206:5;19200:4;19193:19;19258:4;19252;19242:21;19300:9;19294:16;19378;19375:1;19368:27;19429:8;19422:4;19419:1;19415:12;19408:30;19472:11;19465:4;19462:1;19458:12;19451:33;19518:9;19511:4;19508:1;19504:12;19497:31;19562:9;19555:4;19552:1;19548:12;19541:31;19611:4;19608:1;19598:18;19592:4;19585:32;19680:16;19677:1;19670:27;19731:5;19724:4;19721:1;19717:12;19710:27;19771:7;19764:4;19761:1;19757:12;19750:29;19813:5;19806:4;19803:1;19799:12;19792:27;19853:10;19846:4;19843:1;19839:12;19832:32;19898:8;19891:4;19888:1;19884:12;19877:30;19946:4;19943:1;19933:18;19927:4;19920:32;20041:4;20035;20025:21;20019:4;20012:35;20083:1;20077:4;20073:12;20067:4;20060:26;20112:1;20106:4;20099:15;20140:1;20134:4;20127:15;20203:4;20197;20191;20185;20182:1;20175:5;20164:44;20624:5;20605:16;20599:23;20596:34;20586:159;;20663:10;20657:4;20650:24;20726:4;20720;20713:18;20586:159;20830:18;20812:37;;21028:30;21025:43;;21019:4;21012:57;21105:4;21099;21089:21;21082:36;;;21060:7;21225:5;21198:25;-1:-1:-1;21185:4:20;21178:12;;21173:67;21260:4;21253:15;-1:-1:-1;;21330:1:20;21324:4;21317:15;-1:-1:-1;;;;;;;17661:3716:20:o;7549:495::-;7661:14;7746:19;;;;;7742:49;;-1:-1:-1;7774:17:20;7767:24;;7742:49;-1:-1:-1;7884:4:20;7877:21;7924:20;7918:4;7911:34;;;7965:4;7958:19;;;;8022:4;8006:21;;8000:28;;7549:495::o;10363:708:19:-;12517:13;:11;:13::i;:::-;10597:19:::1;10591:4;10584:33;10643:12;10637:4;10630:26;10705:4;10699;10689:21;10811:12;10805:19;10792:11;10789:36;10786:157;;;10857:10;10851:4;10844:24;10924:4;10918;10911:18;10786:157;11020:1;10999:23:::0;;11041::::1;11051:12:::0;11041:9:::1;:23::i;8348:349::-:0;12517:13;:11;:13::i;:::-;8520:8:::1;8516:2;8512:17;8502:150;;8562:10;8556:4;8549:24;8633:4;8627;8620:18;8502:150;8671:19;8681:8;8671:9;:19::i;602:141:8:-:0;702:8;699:1;692:19;728:4;725:1;718:15;22599:1172:20;22669:44;22698:1;22702:2;22706:6;22669:20;:44::i;:::-;22820:18;22814:25;22899:6;22880:17;22876:30;22996:17;22978:16;22975:39;22972:162;;;23046:10;23040:4;23033:24;23115:4;23109;23102:18;22972:162;23221:16;23201:18;23194:44;;;23324:18;23318:4;23311:32;23369:2;23363:4;23356:16;23422:4;23416;23406:21;23538:6;23522:13;23516:20;23512:33;23497:13;23490:56;;23614:6;23608:4;23601:20;23695:4;23689:11;23685:2;23681:20;23678:1;23651:25;23645:4;23639;23634:68;23721:43;23749:1;23753:2;23757:6;23721:19;:43::i;9302:326:6:-;9418:18;;;;;;;:41;;;9440:19;9454:4;9440:13;:19::i;:::-;9414:159;;;9513:53;9537:28;9513:23;:53::i;11776:180:21:-;11911:38;11932:4;11938:2;11942:6;11911:20;:38::i;24177:1119:20:-;24249:46;24270:4;24284:1;24288:6;24249:20;:46::i;:::-;24444:18;24438:4;24431:32;24489:4;24483;24476:18;24546:4;24540;24530:21;24589:15;24583:22;24679:11;24671:6;24668:23;24665:146;;;24723:10;24717:4;24710:24;24792:4;24786;24779:18;24665:146;24903:24;;;24879:49;;25038:18;25032:25;;25028:38;;;25001:66;;-1:-1:-1;25122:20:20;;;25199:22;;;25172:25;25166:4;-1:-1:-1;25155:70:20;25244:45;25264:4;25278:1;25282:6;25244:19;:45::i;20445:226:21:-;20585:10;20579:4;20572:24;20650:4;20644;20637:18;18722:1666;18839:14;18944:1;18999:10;18993:17;18988:3;18984:27;18979:3;18975:37;19149:1;19146;19143:8;19129:686;;19274:2;19193:6;19190:13;-1:-1:-1;19187:1:21;19183:21;19259:9;;;19253:4;19250:19;19247:1;19243:27;19237:34;19234:1;19230:42;;;19226:51;;;;19313:9;;;19306:17;19299:25;;19360:9;;;19353:17;19346:25;;19407:9;;;19400:17;19393:25;;19454:9;;;19447:17;19440:25;;19501:9;;;19494:17;19487:25;;19555:9;;;19548:17;19541:25;;19534:33;;19637:18;;;19631:25;19658:14;19627:46;19619:55;;19609:147;;19707:1;19703:9;;-1:-1:-1;19733:5:21;;19609:147;19778:1;-1:-1:-1;19129:686:21;19858:298;19871:1;19868;19865:8;19858:298;;;19918:1;19915;19911:9;19908:1;19904:17;20018:14;20004:10;20001:1;19997:18;19991:25;19987:46;19982:3;19979:55;19969:150;;20067:1;20063:9;;-1:-1:-1;19858:298:21;;19969:150;20141:1;-1:-1:-1;19858:298:21;;;20206:10;20202:1;20199;20195:9;20191:26;20169:48;;20277:14;20271:21;20267:2;20263:30;20258:1;20251:9;20244:17;20240:54;20230:64;;;20321:9;20313:6;20310:21;20307:65;;20354:14;20350:19;20344:26;20334:36;;20307:65;;18722:1666;;;;:::o;4883:1190:19:-;5793:26;;5883:11;5876:29;;;5793:26;6031:1;5991:38;6031:1;;5980:63;4883:1190;:::o;294:92:1:-;352:29;372:8;529:12:2;616:47:1;554:114;456:282:17;1119:62;;;1100:4;1119:62;;;296:66:18;1119:62:17;;;;;;;;514:182;;560:62;;;:49;:62;;;296:66:18;560:62:17;;;;;:69;;;;625:4;560:69;;;514:182;;;657:32;;;;;;;;;;;;;;514:182;706:27;;;;;;;;;;;456:282;:::o;10751:92:6:-;12517:13:19;:11;:13::i;9632:524:6:-;6449:29:21;6443:4;6436:43;9711:24:6;6492:23:21;;;6560:4;6554;6544:21;6538:28;9835:29:6;;;;;;;;9831:97;;9872:56;9896:31;9872:23;:56::i;:::-;10008:23;;;10004:106;;10041:21;10054:7;10041:12;:21::i;:::-;10004:106;;;10083:20;10095:7;10083:11;:20::i;:::-;10116:35;10132:7;10141:9;10116:15;:35::i;7292:355:19:-;7504:11;7498:18;7488:8;7485:32;7475:156;;7550:10;7544:4;7537:24;7612:4;7606;7599:18;6145:1089;6857:11;7093:16;;6941:26;;;;;;;7053:38;7050:1;;7042:78;7177:27;6145:1089::o;1635:247:1:-;1773:28;;;1698:4;1773:28;;;:19;:28;;;;;;529:12:2;;1773:28:1;;1769:45;;;-1:-1:-1;1810:4:1;;1635:247;-1:-1:-1;;1635:247:1:o;1769:45::-;1846:31;;;;;;;;:22;;;;:31;;-1:-1:-1;1846:31:1;;;;1828:15;:49;;1635:247::o;18134:486:21:-;18203:14;18329:10;18323:17;18318:3;18314:27;18309:3;18305:37;18295:47;;18358:6;18355:249;;;18397:31;18401:14;18397:31;18494:17;;18490:2;18486:26;18543:9;18532:21;;18529:61;;-1:-1:-1;18572:15:21;;18566:22;18529:61;18134:486;;;:::o;12048:437::-;12151:18;;;12147:128;;12185:79;12205:35;8813:15:6;12185:79:21;;12251:6;12259:4;12185:19;:79::i;:::-;;;12147:128;12288:16;;;12284:127;;12320:80;12340:35;8813:15:6;12320:80:21;;12386:6;12394:5;12320:19;:80::i;:::-;;;12284:127;12420:58;12439:15;12449:4;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;12439:15;12456:13;12466:2;6449:29;6443:4;6436:43;6344:14;6492:23;6560:4;6554;6544:21;6538:28;;6277:305;12456:13;12471:6;12420:18;:58::i;1037:318:1:-;529:12:2;1189:18:1;;1091:29;;1171:36;;:15;:36;:::i;:::-;1213:28;;;1244:5;1213:28;;;:19;;;:28;;;;;;;;:36;;;;;;1255:22;;;:31;;;;;:44;;;1311:39;1677:25:24;;;1255:44:1;;-1:-1:-1;1244:5:1;;1311:39;;1650:18:24;1311:39:1;;;;;;;1085:270;;1037:318;:::o;723:234::-;835:28;;;776:29;835:28;;;:19;:28;;;;;;;;:35;;;;866:4;835:35;;;;;;876:22;:31;;;;;:35;;;923:29;;1677:25:24;;;529:12:2;;866:4:1;;835:28;;923:29;;1650:18:24;923:29:1;1531:177:24;14051:660:21;14133:12;14247:9;14243:2;14239:18;14235:2;14231:27;14284:29;14278:4;14271:43;14340:7;14334:4;14327:21;14397:4;14391;14381:21;14429:12;14423:19;14415:27;;14476:2;14462:12;14455:24;;14621:2;14615:4;14607;14601:11;14597:2;14593:20;14558:33;14552:4;14546;14541:83;;14643:61;14662:4;14668:9;14679:24;14695:7;14679:15;:24::i;:::-;14643:18;:61::i;15408:2662::-;15531:16;15549;15677:10;15671:17;15734:16;15729:3;15725:26;15720:3;15716:36;15788:1;15778:668;;15840:6;15833:14;15826:5;15823:25;15813:192;;15889:10;15883:4;15876:24;15978:4;15972;15965:18;15813:192;16038:6;16026:18;;16112:8;16107:3;16103:18;16091:9;16081:8;16078:23;16075:47;16065:199;;16197:2;16193:17;;;16169:42;;16180:10;16169:42;16150:62;;16237:5;;16065:199;16336:9;16332:2;16328:18;16304:43;;16315:10;16304:43;16285:63;;16376:15;;16369:33;;;16423:5;;15778:668;16500:10;16496:1;16493;16489:9;16485:26;16552:14;16546:21;16604:10;16600:2;16596:19;16584:31;;16648:9;16638:8;16635:23;16632:69;;16683:14;16679:19;16673:26;16661:38;;16632:69;16762:5;16752:298;;16821:6;16811:8;16807:21;16795:33;;16876:8;16866;16863:22;16853:43;16889:5;16853:43;16934:10;16928:4;16921:24;17023:4;17017;17010:18;16752:298;17097:6;17087:8;17083:21;17071:33;;17148:8;17138;17135:22;17125:43;17161:5;17125:43;17202:10;17196:4;17189:24;17286:4;17280;17273:18;16718:591;17345:14;17341:31;17399:16;;;17389:217;;17558:10;17554:33;;17535:53;;17448:1;17444:9;;;;17492:22;;;;;17389:217;17655:1;17651:2;17647:10;17641:3;17632:7;17629:16;17626:32;17623:49;;;17661:9;17623:49;;17736:8;17731:3;17727:18;17715:9;17705:8;17702:23;17699:47;17689:191;;17825:8;17821:2;17817:17;17812:1;17808:2;17804:10;17799:3;17796:19;17793:42;17777:14;17770:66;17857:5;;;17689:191;17952:9;17948:2;17944:18;17939:1;17935:2;17931:10;17926:3;17923:19;17920:43;17904:14;17897:67;18009:8;17992:14;17988:19;17981:37;;15701:2353;15705:49;;15408:2662;;;;;;;:::o;12643:1260::-;12744:6;12740:33;;12643:1260;;;:::o;12740:33::-;12826:22;;;;;12850:20;;12885:24;;;12881:37;;12911:7;;12643:1260;;;:::o;12881:37::-;12931:16;;12927:484;;12964:16;12982;13018:75;13038:30;13063:4;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;13038:30;8813:15:6;13018:75:21;;13079:6;13087:5;13018:19;:75::i;:::-;12963:130;;;;13252:8;13246:4;13239:22;13291:8;13285:4;13278:22;13375:11;13334:39;13328:4;13322;13317:70;13163:238;;12927:484;13424:14;;13420:477;;13455:16;13473;13509:72;13529:28;13554:2;15244:29;15238:4;15231:43;15139:14;15287:21;15347:4;15341;15331:21;;15066:302;13529:28;8813:15:6;13509:72:21;;13568:6;13576:4;13509:19;:72::i;:::-;13454:127;;;;13740:8;13734:4;13727:22;13779:8;13773:4;13766:22;13863:9;13822:39;13816:4;13810;13805:68;13651:236;;12730:1173;;12643:1260;;;:::o;11587:128::-;7336:18:20;7330:4;7323:32;;;11662:7:21;7368:19:20;;;7432:4;7416:21;;;7410:28;11688:20:21;7168:286:20;14:332:24;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;180:9;167:23;230:66;223:5;219:78;212:5;209:89;199:117;;312:1;309;302:12;543:477;692:2;681:9;674:21;655:4;724:6;718:13;767:6;762:2;751:9;747:18;740:34;826:6;821:2;813:6;809:15;804:2;793:9;789:18;783:50;882:1;877:2;868:6;857:9;853:22;849:31;842:42;1011:2;941:66;936:2;928:6;924:15;920:88;909:9;905:104;901:113;893:121;;;543:477;;;;:::o;1025:196::-;1093:20;;1153:42;1142:54;;1132:65;;1122:93;;1211:1;1208;1201:12;1226:300;1294:6;1302;1355:2;1343:9;1334:7;1330:23;1326:32;1323:52;;;1371:1;1368;1361:12;1323:52;1394:29;1413:9;1394:29;:::i;:::-;1384:39;1492:2;1477:18;;;;1464:32;;-1:-1:-1;;;1226:300:24:o;1713:374::-;1790:6;1798;1806;1859:2;1847:9;1838:7;1834:23;1830:32;1827:52;;;1875:1;1872;1865:12;1827:52;1898:29;1917:9;1898:29;:::i;:::-;1888:39;;1946:38;1980:2;1969:9;1965:18;1946:38;:::i;:::-;1713:374;;1936:48;;-1:-1:-1;;;2053:2:24;2038:18;;;;2025:32;;1713:374::o;2092:186::-;2151:6;2204:2;2192:9;2183:7;2179:23;2175:32;2172:52;;;2220:1;2217;2210:12;2172:52;2243:29;2262:9;2243:29;:::i;2654:260::-;2722:6;2730;2783:2;2771:9;2762:7;2758:23;2754:32;2751:52;;;2799:1;2796;2789:12;2751:52;2822:29;2841:9;2822:29;:::i;:::-;2812:39;;2870:38;2904:2;2893:9;2889:18;2870:38;:::i;:::-;2860:48;;2654:260;;;;;:::o;2919:660::-;2998:6;3006;3014;3067:2;3055:9;3046:7;3042:23;3038:32;3035:52;;;3083:1;3080;3073:12;3035:52;3106:29;3125:9;3106:29;:::i;:::-;3096:39;;3186:2;3175:9;3171:18;3158:32;3213:18;3205:6;3202:30;3199:50;;;3245:1;3242;3235:12;3199:50;3268:22;;3321:4;3313:13;;3309:27;-1:-1:-1;3299:55:24;;3350:1;3347;3340:12;3299:55;3390:2;3377:16;3416:18;3408:6;3405:30;3402:50;;;3448:1;3445;3438:12;3402:50;3493:7;3488:2;3479:6;3475:2;3471:15;3467:24;3464:37;3461:57;;;3514:1;3511;3504:12;3461:57;2919:660;;3545:2;3537:11;;;;;-1:-1:-1;3567:6:24;;-1:-1:-1;;;2919:660:24:o;4288:156::-;4354:20;;4414:4;4403:16;;4393:27;;4383:55;;4434:1;4431;4424:12;4449:733;4551:6;4559;4567;4575;4583;4591;4644:3;4632:9;4623:7;4619:23;4615:33;4612:53;;;4661:1;4658;4651:12;4612:53;4684:29;4703:9;4684:29;:::i;:::-;4674:39;-1:-1:-1;4782:2:24;4767:18;;4754:32;;-1:-1:-1;4883:2:24;4868:18;;4855:32;;-1:-1:-1;4932:36:24;4964:2;4949:18;;4932:36;:::i;:::-;4449:733;;;;-1:-1:-1;4449:733:24;;5041:3;5026:19;;5013:33;;5145:3;5130:19;;;5117:33;;-1:-1:-1;4449:733:24;-1:-1:-1;;4449:733:24:o;5187:226::-;5246:6;5299:2;5287:9;5278:7;5274:23;5270:32;5267:52;;;5315:1;5312;5305:12;5267:52;-1:-1:-1;5360:23:24;;5187:226;-1:-1:-1;5187:226:24:o;5418:808::-;5529:6;5537;5545;5553;5561;5569;5577;5630:3;5618:9;5609:7;5605:23;5601:33;5598:53;;;5647:1;5644;5637:12;5598:53;5670:29;5689:9;5670:29;:::i;:::-;5660:39;;5718:38;5752:2;5741:9;5737:18;5718:38;:::i;:::-;5708:48;-1:-1:-1;5825:2:24;5810:18;;5797:32;;-1:-1:-1;5926:2:24;5911:18;;5898:32;;-1:-1:-1;5975:37:24;6007:3;5992:19;;5975:37;:::i;:::-;5418:808;;;;-1:-1:-1;5418:808:24;;;;5965:47;6085:3;6070:19;;6057:33;;-1:-1:-1;6189:3:24;6174:19;;;6161:33;;5418:808;-1:-1:-1;;5418:808:24:o;6231:279::-;6296:9;;;6317:10;;;6314:190;;;6360:77;6357:1;6350:88;6461:4;6458:1;6451:15;6489:4;6486:1;6479:15","linkReferences":{},"immutableReferences":{"2795":[{"start":4271,"length":32},{"start":4499,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"bridge()","signatureHash4":"0xe78cea92","signatureHash32":"0xe78cea9276765c085f40dfc1acfb8c748bac2eb031044e073a06f8562ad2ba65"},{"signature":"burn(address,uint256)","signatureHash4":"0x9dc29fac","signatureHash32":"0x9dc29fac0ba6d4fc521c69c2b0c636d612e3343bc39ed934429b8876b0d12cba"},{"signature":"cancelOwnershipHandover()","signatureHash4":"0x54d1f13d","signatureHash32":"0x54d1f13d76f000aa202485e9c4b750a3fb26985ca34157c621201e1375bcbfac"},{"signature":"checkpointAt(address,uint256)","signatureHash4":"0x84a0e082","signatureHash32":"0x84a0e0822409b97df8bbb5f443f9a53fba187d91ed1e93f860deac39ff1f9593"},{"signature":"checkpointCount(address)","signatureHash4":"0x76a82342","signatureHash32":"0x76a82342260a7f1e16a39c55dfb2de538a9645f30b4e466e0519af7120f05d54"},{"signature":"clock()","signatureHash4":"0x91ddadf4","signatureHash32":"0x91ddadf40f7f6ebb77645f9e322f9b8d0ad46a2c9cb2f52a073cd7c5e16d557a"},{"signature":"CLOCK_MODE()","signatureHash4":"0x4bf5d7e9","signatureHash32":"0x4bf5d7e9b6c61a22cbf64ce287b6d2ab7d20c1daf2af0387ee347ff904cd25f5"},{"signature":"completeOwnershipHandover(address)","signatureHash4":"0xf04e283e","signatureHash32":"0xf04e283ea4b43821701876734697fc3e4a42281d51fee656e5c166b741e6afde"},{"signature":"crosschainBurn(address,uint256)","signatureHash4":"0x2b8c49e3","signatureHash32":"0x2b8c49e30e8f566e6ef7fee57b24d77a9ffbb703f355647286895f7b9adc5ee9"},{"signature":"crosschainMint(address,uint256)","signatureHash4":"0x18bf5077","signatureHash32":"0x18bf5077a7f5e95fa926f81f42016d8502ae74ca0542d5492093641a7684e400"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"delegate(address)","signatureHash4":"0x5c19a95c","signatureHash32":"0x5c19a95c96fe5699f69181241d04ecef12a0c89506c08c7360f0f7e9a556859f"},{"signature":"delegateBySig(address,uint256,uint256,uint8,bytes32,bytes32)","signatureHash4":"0xc3cda520","signatureHash32":"0xc3cda520413c90ac2c469da30542aa0b90cd877a87f60aecc55e99ec7019c59e"},{"signature":"delegates(address)","signatureHash4":"0x587cde1e","signatureHash32":"0x587cde1e7a8c573b1844af1585c2f1cfd2d254aa7bdef08253e217600cd8476c"},{"signature":"DOMAIN_SEPARATOR()","signatureHash4":"0x3644e515","signatureHash32":"0x3644e5157256d68e3eeedd2ead302507a9c4ffaff665547d2c3623a1e9e7edf4"},{"signature":"getPastVotes(address,uint256)","signatureHash4":"0x3a46b1a8","signatureHash32":"0x3a46b1a8034ed3adfd5d8c1bf75e426a415502bced856c6b8d65c6d81fd746ce"},{"signature":"getPastVotesTotalSupply(uint256)","signatureHash4":"0xc7a2f1de","signatureHash32":"0xc7a2f1de27c374d3e39c04e42e79186000394959e7f8ecaab16cc0deb1eebfc2"},{"signature":"getVotes(address)","signatureHash4":"0x9ab24eb0","signatureHash32":"0x9ab24eb0086abe93529cb36564cc78c9de7e8a990a4616ff863202cfd413aa9e"},{"signature":"getVotesTotalSupply()","signatureHash4":"0xcd63c4d2","signatureHash32":"0xcd63c4d227697190e412d1728ff34c242a28992014992e85ec1bee086abd12e2"},{"signature":"initialize(address,address)","signatureHash4":"0x485cc955","signatureHash32":"0x485cc955cd05f29985ce37d87ac35dcf2fdbc60b9106f66a532e31a2f1d5743b"},{"signature":"isLockActive(address)","signatureHash4":"0x7f73540c","signatureHash32":"0x7f73540c01800185b55adf26ea363421e4d111aed3ff38dc001d19f3f2346489"},{"signature":"l1Token()","signatureHash4":"0xc01e1bd6","signatureHash32":"0xc01e1bd6212b650615429a817de7fdd3b8129e26fe14d7af04abc0f7938b6524"},{"signature":"l2Bridge()","signatureHash4":"0xae1f6aaf","signatureHash32":"0xae1f6aafc9bf00ee23f65a47aec3e701b5332b15de243985c0e7aad934fbd4f3"},{"signature":"lockExpiration(address)","signatureHash4":"0x28162566","signatureHash32":"0x28162566436d54a339ea2d05a725590ac82146aa2c81ba330639850157e15ccd"},{"signature":"mint(address,uint256)","signatureHash4":"0x40c10f19","signatureHash32":"0x40c10f19c047ae7dfa66d6312b683d2ea3dfbcb4159e96b967c5f4b0a86f2842"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"nonces(address)","signatureHash4":"0x7ecebe00","signatureHash32":"0x7ecebe00bc8d5df94a191da8e29b79e67a22b668e14b756a81ef2f5fa215cb0c"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownershipHandoverExpiresAt(address)","signatureHash4":"0xfee81cf4","signatureHash32":"0xfee81cf4fcd7f51611a3bf33478e3ef123da30b6dfa31a0b2a6d1192ef3c7e02"},{"signature":"permit(address,address,uint256,uint256,uint8,bytes32,bytes32)","signatureHash4":"0xd505accf","signatureHash32":"0xd505accfee7b46ac3ce97322c21f328b64073d188137e16f7ef87f8de076b51c"},{"signature":"proxiableUUID()","signatureHash4":"0x52d1902d","signatureHash32":"0x52d1902ddf94a87b87c42e6ab3aff7da3c30beb57dc65dd86cb2543522a55a4c"},{"signature":"remoteToken()","signatureHash4":"0xd6c0b2c4","signatureHash32":"0xd6c0b2c4d7fd1c589fefd4962a0d738630107cb39528e6d90d41ea80a18cdd71"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"requestOwnershipHandover()","signatureHash4":"0x25692962","signatureHash32":"0x25692962a9adba4272ff0251e0e6793c55bbf553e4476049416aa620e8960301"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"upgradeToAndCall(address,bytes)","signatureHash4":"0x4f1ef286","signatureHash32":"0x4f1ef2866b98625bdfefae89411f7a82754ac4089eff8e78c8832329a538337f"},{"signature":"version()","signatureHash4":"0x54fd4d50","signatureHash32":"0x54fd4d50fce680dbc2593d9e893064bfa880e5642d0036394e1a1849f7fc0749"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"CrosschainBurn(address,uint256,address)","signatureHash4":"0xb90795a6","signatureHash32":"0xb90795a66650155983e242cac3e1ac1a4dc26f8ed2987f3ce416a34e00111fd4"},{"signature":"CrosschainMint(address,uint256,address)","signatureHash4":"0xde22baff","signatureHash32":"0xde22baff038e3a3e08407cbdf617deed74e869a7ba517df611e33131c6e6ea04"},{"signature":"DelegateChanged(address,address,address)","signatureHash4":"0x3134e8a2","signatureHash32":"0x3134e8a2e6d97e929a7e54011ea5485d7d196dd5f0ba4d4ef95803e8e3fc257f"},{"signature":"DelegateVotesChanged(address,uint256,uint256)","signatureHash4":"0xdec2bacd","signatureHash32":"0xdec2bacdd2f05b59de34da9b523dff8be42e5e38e818c82fdb0bae774387a724"},{"signature":"Initialized(uint64)","signatureHash4":"0xc7f505b2","signatureHash32":"0xc7f505b2f371ae2175ee4913f4499e1f2633a7b5936321eed1cdaeb6115181d2"},{"signature":"InterfaceAdded(bytes4)","signatureHash4":"0x78f84e5b","signatureHash32":"0x78f84e5b1c5c05be2b5ad3800781dd404d6d6c6302bc755c0fe20f58a33a7f22"},{"signature":"InterfaceRemoved(bytes4)","signatureHash4":"0x8bd38356","signatureHash32":"0x8bd383568d0bc57b64b8e424138fc19ae827e694e05757faa8fea8f63fb87315"},{"signature":"LockUpdated(address,bool,uint256)","signatureHash4":"0xe16066c9","signatureHash32":"0xe16066c96aababa72475f0b2768d3b6181ea150033042b37d0646737caa4a501"},{"signature":"OwnershipHandoverCanceled(address)","signatureHash4":"0xfa7b8eab","signatureHash32":"0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92"},{"signature":"OwnershipHandoverRequested(address)","signatureHash4":"0xdbf36a10","signatureHash32":"0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"},{"signature":"Upgraded(address)","signatureHash4":"0xbc7cd75a","signatureHash32":"0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b"}],"error":[{"signature":"AllowanceOverflow()","signatureHash4":"0xf9067066","signatureHash32":"0xf90670665e03a4773b0ff0038950e59dcf6eb0e11a551c751bfc6d601d4fba1f"},{"signature":"AllowanceUnderflow()","signatureHash4":"0x8301ab38","signatureHash32":"0x8301ab3813d043283976247523a0a38774b9155d7216ecc20ceae2039c28e28f"},{"signature":"AlreadyInitialized()","signatureHash4":"0x0dc149f0","signatureHash32":"0x0dc149f07762891dbcea3fe72770f3d63a1863fc54b2f084e8c59ec476996927"},{"signature":"DelegateeSameAsCurrent()","signatureHash4":"0x09ca3c9c","signatureHash32":"0x09ca3c9ce3f2e759456c07caa175fb34c7e7a08802e8990e8a2ead650a93f5a9"},{"signature":"ERC5805CheckpointIndexOutOfBounds()","signatureHash4":"0x86df9d10","signatureHash32":"0x86df9d1096a77e2f351cc6918bf186b9828c1bc551b615f4f27033286427589a"},{"signature":"ERC5805CheckpointValueOverflow()","signatureHash4":"0x9dbbeb75","signatureHash32":"0x9dbbeb7597ed4c8a6e34e32bf4350afae9d28fe79da2982d884a4d7e5b9ac4ca"},{"signature":"ERC5805CheckpointValueUnderflow()","signatureHash4":"0x5915f686","signatureHash32":"0x5915f686ed04a2e3119fe1f2f38129cf8e7c3d901d404576a5a4379b864738ea"},{"signature":"ERC5805DelegateInvalidSignature()","signatureHash4":"0x1838d95c","signatureHash32":"0x1838d95cd46fcfadd423d3217eb46c5f4334ecad8f15f73fe858c495e19003ef"},{"signature":"ERC5805DelegateSignatureExpired()","signatureHash4":"0x3480e9e1","signatureHash32":"0x3480e9e1cd14a3a585a49e8823bea2b5d7bf4dbd27689018d308ec527ad07a46"},{"signature":"ERC5805FutureLookup()","signatureHash4":"0xf9874464","signatureHash32":"0xf98744647cf2f7fa23bc79d54329d9f959a2ad1a9f71fb57a00e38ba5d27ac0f"},{"signature":"InsufficientAllowance()","signatureHash4":"0x13be252b","signatureHash32":"0x13be252bc8f22c3de689f75d88d90b4c4aeb9cd39d50c39ae82df3b19f85cf73"},{"signature":"InsufficientBalance()","signatureHash4":"0xf4d678b8","signatureHash32":"0xf4d678b8ce6b5157126b1484a53523762a93571537a7d5ae97d8014a44715c94"},{"signature":"Introspection_AlreadySupported()","signatureHash4":"0xf2cfeefa","signatureHash32":"0xf2cfeefa34f98f35aecd897af14c31c8cd9c9abd48988af0a47d51fefe7d458f"},{"signature":"Introspection_NotSupported()","signatureHash4":"0xeafe1fae","signatureHash32":"0xeafe1fae2b7bb83c64b7e35817715bd128a7dcc092b9b12d0115df214606c9c2"},{"signature":"InvalidInitialization()","signatureHash4":"0xf92ee8a9","signatureHash32":"0xf92ee8a957075833165f68c320933b1a1294aafc84ee6e0dd3fb178008f9aaf5"},{"signature":"InvalidPermit()","signatureHash4":"0xddafbaef","signatureHash32":"0xddafbaefe5cdbfc41219261b5d7468d1f16bc986eedbdef2ea223830eb9c5e3e"},{"signature":"LockNotAuthorized()","signatureHash4":"0x010e928c","signatureHash32":"0x010e928c05479183578184479ac42d7f7a8abbb44d69c81c1a85c173d3196704"},{"signature":"NewOwnerIsZeroAddress()","signatureHash4":"0x7448fbae","signatureHash32":"0x7448fbae245b5163a637f61fac94c5376c3e155928452ce47ee52d8c1b99587a"},{"signature":"NoHandoverRequest()","signatureHash4":"0x6f5e8818","signatureHash32":"0x6f5e8818469c73d5be4a0d17c371cde64695907022629c1d064c895f98d466a6"},{"signature":"NotInitializing()","signatureHash4":"0xd7e6bcf8","signatureHash32":"0xd7e6bcf8597daa127dc9f0048d2f08d5ef140a2cb659feabd700beff1f7a8302"},{"signature":"Permit2AllowanceIsFixedAtInfinity()","signatureHash4":"0x3f68539a","signatureHash32":"0x3f68539a770258d2bb543cd58b5796e9a7d3756f652a2877fca18c376b7d6d2d"},{"signature":"PermitExpired()","signatureHash4":"0x1a15a3cc","signatureHash32":"0x1a15a3cc224edbade4d933d5c6e98dd80b0bac0717489018b924d44d9f0272ea"},{"signature":"TotalSupplyOverflow()","signatureHash4":"0xe5cfe957","signatureHash32":"0xe5cfe9574234d28adee0e141da16b8cf97573d6cdb05963cf8520ef32a8feff8"},{"signature":"TransferLockEnabled()","signatureHash4":"0x55c42195","signatureHash32":"0x55c42195ee628f0f123300f03fe8a011bbcf759a26cbfc1f4e170202e743055f"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"UnauthorizedCallContext()","signatureHash4":"0x9f03a026","signatureHash32":"0x9f03a026210d6e1d73a6bb286502827a91a864e6fb88b45d0431438ccf6f87f1"},{"signature":"UpgradeFailed()","signatureHash4":"0x55299b49","signatureHash32":"0x55299b49652ca9ce92a8bd64b03e77919c7a18398e35089bb02c00e739b87f18"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"8453","address":"0x18DDF8bf26B35c8D70C7514105930Ae766c7c172"}