{"matchId":"51416150","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-09-21T08:48:40Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"137:313:9:-:0;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;299:20;;137:313;;;;;;;;299:20;137:313;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;-1:-1:-1;137:313:9;;;;;-1:-1:-1;137:313:9","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e2fb320215783417f0d03eadac743b8ea521353ce3d3b7d6166a03b67b81aff564736f6c634300081c0033","offset":5395}},"transformations":[{"type":"insert","offset":5448,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000f75584ef6673ad213a685a1b58cc0330b8ea22cf"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"137:313:9:-:0;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;137:313:9;;;;;;;;;;;;;;;;-1:-1:-1;;;775:49:3;;;:89;;;;137:313:9;;;;;;;;;775:89:3;-1:-1:-1;;;862:40:6;;-1:-1:-1;775:89:3;;;137:313:9;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;;;;137:313:9;;;;;;-1:-1:-1;;137:313:9;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;-1:-1:-1;;137:313:9;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;137:313:9;;;;;;1073:38:8;137:313:9;;;1033:25:8;137:313:9;;;;;;:::i;:::-;960:23:8;;:::i;:::-;137:313:9;;;:::i;:::-;1033:25:8;;:::i;:::-;137:313:9;;;;;;;;;;;;;;1073:38:8;137:313:9;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;191:33;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;:::i;:::-;;;;;;;;;332:116;410:8;-1:-1:-1;;;;;137:313:9;396:10;:22;392:49;;332:116::o;392:49::-;427:14;;;;;;;;137:313;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;180:4:0:-;137:313:9;;180:4:0;;;;;;;;;;;;:::o;:::-;;;;:::o;:::-;137:313:9;;-1:-1:-1;;;180:4:0;;;;;;;;;;;137:313:9;-1:-1:-1;;;137:313:9;;;180:4:0;;;;;137:313:9;;;;;180:4:0;;137:313:9;180:4:0;;;;;;:::o;:::-;;;;137:313:9;180:4:0;;;137:313:9;180:4:0;;:::o;465::1:-;137:313:9;;;465:4:1;;;;;;;;;-1:-1:-1;;465:4:1;;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;465:4:1;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;137:313:9;;;;;;;:::i;:::-;465:4:1;;;-1:-1:-1;465:4:1;;;;:::o;:::-;137:313:9;465:4:1;:::o;:::-;137:313:9;;;;;;;:::i;:::-;465:4:1;;;-1:-1:-1;;;137:313:9;465:4:1;;;:::o;:::-;137:313:9;;;-1:-1:-1;;;;;137:313:9;;;465:4:1;;;137:313:9;465:4:1;;;;;;;;;;;;;:::i;:::-;;:::o;806:5657::-;;137:313:9;1163:18:1;;;;;;6444:12;;;806:5657;:::o;1183:26::-;1235:11;;;;;:::i;:::-;137:313:9;1289:13:1;1268:37;1276:28;1282:21;1289:13;;137:313:9;;;;1289:13:1;-1:-1:-1;;;;;;137:313:9;;;1282:21:1;137:313:9;;;;1276:28:1;137:313:9;;;;1268:37:1;1324:29;516:4;1324:29;;:34;;;;;137:313:9;;1432:11:1;;;;;;:::i;:::-;137:313:9;1300:2:1;1320:310;;426:4;1648:20;;289:4;1648:36;;289:4;;-1:-1:-1;137:313:9;;;;1826:399:1;1300:2;1826:17;;1300:2;;1875:180;;-1:-1:-1;;;;;;137:313:9;;1875:180:1;;:::i;:::-;1725:518;;;1300:2;1725:518;137:313:9;-1:-1:-1;;;;;137:313:9;;1725:518:1;;;;;:::i;:::-;1704:539;1644:2446;4109:7;4108:8;;4104:2093;;-1:-1:-1;;563:4:1;6215:25;:30;563:4;;7080:3;6289:13;;6282:21;6289:13;6305:7;6289:13;137:313:9;;;;6282:21:1;6305:7;;:::i;:::-;137:313:9;;;;7080:3:1;1152:9;;6211:214;6386:13;7080:3;6386:13;;6379:21;6386:13;6360:50;6386:13;137:313:9;;;;6379:21:1;6360:50;;:::i;:::-;6211:214;7080:3;:::i;4104:2093::-;465:4;;;;;:::i;:::-;137:313:9;4208:2:1;137:313:9;;4191:19:1;4187:1703;;4104:2093;5967:94;;;5914:268;5967:94;;;;;;;516:4;137:313:9;-1:-1:-1;;;5914:268:1;;137:313:9;;;-1:-1:-1;;;;;137:313:9;;5914:268:1;;;;:::i;:::-;;;;5967:94;6056:5;;;:::i;:::-;5967:94;;;4187:1703;1300:2;4715:16;4585:83;4412:33;;;:::i;:::-;4585:83;;4715:16;:::i;:::-;4758:13;4187:1703;4754:1118;5038:16;4898:92;;;5038:16;:::i;:::-;5522:23;5518:332;;4754:1118;;4187:1703;;5518:332;4208:2;5669:100;;-1:-1:-1;5914:268:1;5518:332;;1826:399;137:313:9;180:4:0;2082:143:1;137:313:9;;;2117:82:1;2082:143;;:::i;:::-;;1826:399;;1644:2446;337:4;2268:42;;337:4;;-1:-1:-1;137:313:9;;;;2487:435:1;1300:2;2487:17;;1300:2;;2540:196;;-1:-1:-1;;;;;;137:313:9;;2540:196:1;;:::i;:::-;2351:593;;;1300:2;2351:593;-1:-1:-1;;;;;137:313:9;;2351:593:1;;;;;:::i;:::-;2330:614;1644:2446;;2487:435;137:313:9;180:4:0;2767:155:1;137:313:9;;;2806:86:1;2767:155;;:::i;:::-;;2487:435;;2264:1826;426:4;2969:41;426:4;;137:313:9;;;3277:10:1;3047:119;180:4:0;137:313:9;;;;3074:74:1;3047:119;;:::i;:::-;;3184:49;1300:2;137:313:9;;3192:14:1;3184:49;:::i;:::-;3277:10;:::i;:::-;3482:510;1300:2;3482:17;;:22;1300:2;;;;3697:17;3635:12;3531:254;3635:12;137:313:9;;;;3635:12:1;3697:17;;:::i;:::-;137:313:9;-1:-1:-1;;;;;;137:313:9;;3531:254:1;;:::i;:::-;3482:510;;3327:683;;;1300:2;3327:683;;-1:-1:-1;;;;;137:313:9;;3327:683:1;;;;;:::i;3482:510::-;3860:12;180:4:0;3847:119:1;:27;3853:20;3860:12;3812:180;3860:12;137:313:9;;;;3847:119:1;;3812:180;;:::i;:::-;;3482:510;;;2965:1125;516:4;137:313:9;-1:-1:-1;;;4049:26:1;;384:4;4049:26;;;384:4;;;;;137:313:9;-1:-1:-1;;;137:313:9;;;384:4:1;;;5914:268;1320:310;620:66;1614:1;137:313:9;;;;-1:-1:-1;;;;;1536:43:1;1320:310;;137:313:9;;;;;;;;;;:::i;:::-;916:2:0;137:313:9;;;-1:-1:-1;;137:313:9;;;;;;:::o;268:4:0:-;;2314:1;268:4;;;;;;;:::o;:::-;;465::1;;;:::i;:::-;137:313:9;;;;;;:::i;:::-;465:4:1;;;268::0;137:313:9;268:4:0;137:313:9;;268:4:0;;:::i;:::-;;137:313:9;268:4:0;137:313:9;268:4:0;;137:313:9;268:4:0:o;414:4762::-;;;;;;137:313:9;;792:12:0;137:313:9;902:17:0;;;:::i;:::-;1032:22;137:313:9;1185:9:0;137:313:9;1180:1079:0;1196:17;;;;;;1180:1079;2306:9;;;2296:20;2306:9;;:::i;:::-;2296:20;:::i;:::-;2326:63;1243:10;2326:63;;;137:313:9;2471:54:0;;;;2539:9;137:313:9;2534:2636:0;2550:17;;;;;;414:4762;;;;;;;;;:::o;2539:9::-;1243:10;2597;;;;;;;;;;563:4:1;2626:25:0;;:30;563:4:1;;268::0;2680:20;;268:4;;2724:76;;;1243:10;2724:76;137:313:9;2724:76:0;;;2821:59;2848:8;;;;:::i;:::-;2858:21;137:313:9;;2858:21:0;:::i;:::-;2821:59;;;:::i;:::-;137:313:9;;268:4:0;-1:-1:-1;;268:4:0;;2676:2057;268:4;137:313:9;;2539:9:0;;;;2676:2057;313:4;3018:22;;;;;;;3014:1719;313:4;;;3138:76;;3260:265;3138:76;;;137:313:9;3138:76:0;;;;;;;1243:10;3138:76;;3260:265;:::i;:::-;3235:290;;;;;;3014:1719;2676:2057;;3014:1719;358:4;3554:22;;358:4;;3674:76;;3796:265;3674:76;;;137:313:9;3674:76:0;;;;;;;1243:10;3674:76;;3796:265;:::i;3550:1183::-;4175:20;4417:203;4175:20;;;4449:27;1243:10;4175:20;180:4;137:313:9;4175:20:0;;;;;4169:27;;;;;:::i;:::-;;137:313:9;4320:76:0;;;;4449:27;:::i;:::-;;4558:8;;;;:::i;:::-;4417:203;;:::i;:::-;268:4;3550:1183;2676:2057;;2622:2450;1243:10;4881:20;;137:313:9;4881:20:0;;;;4875:27;180:4;4881:20;;;4875:27;;:::i;:::-;;4970:88;;;;2622:2450;;1185:9;1243:10;;;;;;;;;;;;;225:4;1272:22;;1268:101;;563:4:1;1386:25:0;;:30;563:4:1;;268::0;1440:20;;268:4;;137:313:9;;;1488:21:0;1484:105;;1436:627;1243:10;137:313:9;;;;268:4:0;1436:627;;268:4;;1185:9;137:313:9;;1185:9:0;;1484:105;137:313:9;;;1243:10:0;137:313:9;;1549:17:0;;;;;;;;:::i;:::-;;137:313:9;;1549:17:0;;;;;;:::i;:::-;1484:105;;;;;;1436:627;1780:264;;;137:313:9;1780:264:0;;1243:10;1780:264;;;;;:::i;:::-;1740:304;;;;;;1436:627;;;1382:780;2109:38;1243:10;2109:38;137:313:9;2109:38:0;;;:::i;:::-;1382:780;;;1268:101;-1:-1:-1;1314:17:0;;-1:-1:-1;1314:17:0;;1349:5;1314:17;-1:-1:-1;2306:9:0;2296:20;1349:5;;6469:500:1;;137:313:9;;465:4:1;;;;;;;;;6696:15;4208:2;6713:10;;;;;;6469:500;;;:::o;6696:15::-;137:313:9;;;;;;;;;;;;;-1:-1:-1;;;;;;137:313:9;6745:12:1;6741:153;;137:313:9;;6696:15:1;;6741:153;6849:7;;;;;465:4;;;;;;;;;6874:5;6469:500::o;137:313:9:-;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;137:313:9;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;15257:1683:0;;;137:313:9;;;;15455:22:0;;15451:40;;563:4:1;15506:25:0;;:30;563:4:1;;268::0;15556:20;;268:4;;137:313:9;;15604:29:0;137:313:9;;15604:29:0;137:313:9;;;15604:29:0;;;;;;:::i;15552:1041::-;15883:81;137:313:9;15672:67:0;16125:454;137:313:9;180:4:0;137:313:9;;15680:20:0;;:35;15672:67;:::i;:::-;15883:81;;;;15981:125;15883:81;;;16010:12;15981:125;:::i;:::-;16125:454;-1:-1:-1;;16125:454:0;;;;;;;;;;465:4:1;:::o;15502:1409:0:-;16864:36;16631:20;;;180:4;16631:20;137:313:9;16623:67:0;137:313:9;;16631:35:0;;16623:67;:::i;:::-;16731:118;16773:2;137:313:9;;16756:19:0;16731:118;:::i;:::-;16864:36;;;;:::i;:::-;;;;:::i;:::-;;15257:1683;:::o;15451:40::-;15479:12;;;;:::o;16946:454::-;;137:313:9;;;17117:22:0;;17113:35;;137:313:9;;268:4:0;17235:2;268:4;;;;;;;17235:2;17209:29;180:4;17209:29;17179:59;17209:29;;:::i;:::-;17185:20;;17179:59;;;;;:::i;:::-;;;:::i;:::-;;137:313:9;;;17575:292:0;;;;;;;;;;;17301:93;17575:292;;17301:93;16946:454::o;17113:35::-;17141:7;;;:::o;5182:358::-;5363:27;5182:358;180:4;5401:2;5182:358;;5369:20;5363:27;;:::i;:::-;;137:313:9;5363:40:0;137:313:9;;5401:2:0;268:4;5182:358;:::o;137:313:9:-;;;-1:-1:-1;;;137:313:9;;5401:2:0;137:313:9;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;6192:1182:0;;;;;;;313:4;6583:22;;313:4;;6677:184;;;;;;:::i;:::-;6621:240;;;6579:789;6192:1182::o;6579:789::-;358:4;6882:22;;358:4;;6976:184;;;;;;:::i;6878:490::-;7191:34;;-1:-1:-1;7191:34:0;;;;;5726:27;;180:4;5732:20;;5726:27;:::i;:::-;;137:313:9;5893:11:0;;;:31;;;6878:490;137:313:9;;;268:4:0;6167:2;268:4;;6192:1182::o;137:313:9:-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;5893:31:0;137:313:9;;;;5908:16:0;5893:31;;17406:467;;17575:292;17406:467;;;;17575:292;;;;;;;;17406:467::o;:::-;17575:292;;1243:10;17575:292;;17406:467;;17575:292;;;;;;17406:467::o;11339:3912::-;;;;;;;137:313:9;11785:25:0;;;;;:::i;:::-;137:313:9;268:4:0;12164:78;11981:1;268:4;;;;;;;;12164:78;;;;12251:2994;12258:13;12269:2;12258:13;;;;12251:2994;11339:3912;;;;;;:::o;12251:2994::-;12299:17;;;563:4:1;12335:25:0;;:30;563:4:1;;403::0;12389:22;;403:4;;12435:5;;;12385:2330;313:4;12469:22;;;;;;;;;;;;;12465:2250;313:4;;;12589:89;;12743:278;12589:89;;;;;12743:278;;;;;:::i;:::-;;12269:2;12743:278;;;11981:1;12743:278;;;;12699:322;;;;;;;;268:4;;;;;12465:2250;;268:4;137:313:9;;12251:2994:0;;;;;;;;12465:2250;358:4;13218:22;;358:4;;13338:89;;13492:278;13338:89;;;;;13492:278;;;;;:::i;:::-;;12269:2;13492:278;;;11981:1;13492:278;;;;13448:322;;;;;;;;268:4;;;;;13214:1501;12465:2250;;13214:1501;12269:2;14045:20;;;11981:1;14045:20;;;;;;14279:206;180:4;14045:20;;;14039:27;;14311;14039;;;;:::i;:::-;;137:313:9;14169:89:0;;;;;;;;14311:27;:::i;14279:206::-;268:4;;;;;;13214:1501;12465:2250;;12331:2803;12269:2;11981:1;14863:20;;;;;;;14857:27;14863:20;180:4;14863:20;;;;;;14857:27;;:::i;:::-;;14946:94;;;;268:4;12331:2803;;;10153:1180;;;;;;;10620:1;268:4;10732:17;10659:2;10732:17;;;;;10659:2;11035:179;10732:17;;10848:27;180:4;10732:17;;;10854:20;10848:27;;:::i;:::-;;10885:97;;;;;;;;268:4;11035:179;;:::i;:::-;;;;;;;10659:2;268:4;;;;10153:1180::o;137:313:9:-;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;8333:1814:0;8912:1;268:4;;;;8988:2;268:4;;;;;;8333:1814;137:313:9;;8333:1814:0;;;9017:13;8988:2;9017:13;;;;137:313:9;;-1:-1:-1;;;10094:46:0;;137:313:9;10094:46:0;;;137:313:9;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;5914:268:1;9010:1075:0;9058:17;;;563:4:1;9094:25:0;;:30;563:4:1;;403::0;9148:22;;403:4;;9194:37;;;;;;;:::i;:::-;137:313:9;9316:60:0;;;;:::o;9144:730::-;9575:280;9431:20;;9423:74;268:4;9431:20;;;;;;;;;;9423:74;:::i;:::-;9575:280;;;:::i;:::-;;;;;;;;;;8912:1;;8988:2;;9090:889;268:4;137:313:9;;9010:1075:0;;;9090:889;9923:41;8988:2;9923:41;8912:1;9923:41;;;;;;:::i;:::-;9090:889;;;7380:947;;;;;;7872:1;268:4;7948:17;7906:2;7948:17;;;;;7906:2;7997:27;180:4;7948:17;;;8003:20;7997:27;;:::i;:::-;;137:313:9;7997:40:0;137:313:9;;7906:2:0;8158:162;268:4;;8158:162;;:::i;137:313:9:-;;;-1:-1:-1;;;137:313:9;;7906:2:0;137:313:9;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e2fb320215783417f0d03eadac743b8ea521353ce3d3b7d6166a03b67b81aff564736f6c634300081c0033","offset":5261}},"immutableReferences":{"1971":[{"start":1138,"length":32},{"start":1379,"length":32}]},"transformations":[{"id":"1971","type":"replace","offset":1138,"reason":"immutable"},{"id":"1971","type":"replace","offset":1379,"reason":"immutable"}],"transformationValues":{"immutables":{"1971":"0x000000000000000000000000f75584ef6673ad213a685a1b58cc0330b8ea22cf"}}},"deployment":{"transactionHash":"0x868fb3283d1c970dc3f5a3eeb163ab55e6ad950fd41d196aab7fa9c1563864f5","blockNumber":"22191812","transactionIndex":"108","deployer":"0x826e0BB2276271eFdF2a500597f37b94f6c153bA"},"sources":{"lib/enso-weiroll/contracts/CommandBuilder.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.16;\n\nlibrary CommandBuilder {\n    uint256 constant IDX_VARIABLE_LENGTH = 0x80;\n    uint256 constant IDX_VALUE_MASK = 0x7f;\n    uint256 constant IDX_END_OF_ARGS = 0xff;\n    uint256 constant IDX_USE_STATE = 0xfe;\n    uint256 constant IDX_ARRAY_START = 0xfd;\n    uint256 constant IDX_TUPLE_START = 0xfc;\n    uint256 constant IDX_DYNAMIC_END = 0xfb;\n\n    function buildInputs(\n        bytes[] memory state,\n        bytes4 selector,\n        bytes32 indices,\n        uint256 indicesLength\n    ) internal view returns (bytes memory ret) {\n        uint256 idx; // The current command index\n        uint256 offsetIdx; // The index of the current free offset\n\n        uint256 count; // Number of bytes in whole ABI encoded message\n        uint256 free; // Pointer to first free byte in tail part of message\n        uint256[] memory dynamicLengths = new uint256[](10); // Optionally store the length of all dynamic types (a command cannot fit more than 10 dynamic types)\n\n        bytes memory stateData; // Optionally encode the current state if the call requires it\n\n        // Determine the length of the encoded data\n        for (uint256 i; i < indicesLength; ) {\n            idx = uint8(indices[i]);\n            if (idx == IDX_END_OF_ARGS) {\n                indicesLength = i;\n                break;\n            }\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_USE_STATE) {\n                    if (stateData.length == 0) {\n                        stateData = abi.encode(state);\n                    }\n                    unchecked {\n                        count += stateData.length;\n                    }\n                } else {\n                    (dynamicLengths, offsetIdx, count, i) = setupDynamicType(\n                        state,\n                        indices,\n                        dynamicLengths,\n                        idx,\n                        offsetIdx,\n                        count,\n                        i\n                    );\n                }\n            } else {\n                count = setupStaticVariable(state, count, idx);\n            }\n            unchecked {\n                free += 32;\n                ++i;\n            }\n        }\n\n        // Encode it\n        ret = new bytes(count + 4);\n        assembly {\n            mstore(add(ret, 32), selector)\n        }\n        offsetIdx = 0;\n        // Use count to track current memory slot\n        assembly {\n            count := add(ret, 36)\n        }\n        for (uint256 i; i < indicesLength; ) {\n            idx = uint8(indices[i]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_USE_STATE) {\n                    assembly {\n                        mstore(count, free)\n                    }\n                    memcpy(stateData, 32, ret, free + 4, stateData.length - 32);\n                    unchecked {\n                        free += stateData.length - 32;\n                    }\n                } else if (idx == IDX_ARRAY_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    (offsetIdx, free, i, ) = encodeDynamicArray(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        offsetIdx,\n                        free,\n                        i\n                    );\n                } else if (idx == IDX_TUPLE_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    (offsetIdx, free, i, ) = encodeDynamicTuple(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        offsetIdx,\n                        free,\n                        i\n                    );\n                } else {\n                    // Variable length data\n                    uint256 argLen = state[idx & IDX_VALUE_MASK].length;\n                    // Put a pointer in the current slot and write the data to first free slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    memcpy(\n                        state[idx & IDX_VALUE_MASK],\n                        0,\n                        ret,\n                        free + 4,\n                        argLen\n                    );\n                    unchecked {\n                        free += argLen;\n                    }\n                }\n            } else {\n                // Fixed length data (length previously checked to be 32 bytes)\n                bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n                // Write the data to current slot\n                assembly {\n                    mstore(count, mload(add(stateVar, 32)))\n                }\n            }\n            unchecked {\n                count += 32;\n                ++i;\n            }\n        }\n    }\n\n    function setupStaticVariable(\n        bytes[] memory state,\n        uint256 count,\n        uint256 idx\n    ) internal pure returns (uint256 newCount) {\n        require(\n            state[idx & IDX_VALUE_MASK].length == 32,\n            \"Static state variables must be 32 bytes\"\n        );\n        unchecked {\n            newCount = count + 32;\n        }\n    }\n\n    function setupDynamicVariable(\n        bytes[] memory state,\n        uint256 count,\n        uint256 idx\n    ) internal pure returns (uint256 newCount) {\n        bytes memory arg = state[idx & IDX_VALUE_MASK];\n        // Validate the length of the data in state is a multiple of 32\n        uint256 argLen = arg.length;\n        require(\n            argLen != 0 && argLen % 32 == 0,\n            \"Dynamic state variables must be a multiple of 32 bytes\"\n        );\n        // Add the length of the value, rounded up to the next word boundary, plus space for pointer\n        unchecked {\n            newCount = count + argLen + 32;\n        }\n    }\n\n    function setupDynamicType(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 idx,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        if (idx == IDX_ARRAY_START) {\n            (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicArray(\n                state,\n                indices,\n                dynamicLengths,\n                offsetIdx,\n                count,\n                index\n            );\n        } else if (idx == IDX_TUPLE_START) {\n            (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicTuple(\n                state,\n                indices,\n                dynamicLengths,\n                offsetIdx,\n                count,\n                index\n            );\n        } else {\n            newDynamicLengths = dynamicLengths;\n            newOffsetIdx = offsetIdx;\n            newIndex = index;\n            newCount = setupDynamicVariable(state, count, idx);\n        }\n    }\n\n    function setupDynamicArray(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        // Current idx is IDX_ARRAY_START, next idx will contain the array length\n        unchecked {\n            newIndex = index + 1;\n            newCount = count + 32;\n        }\n        uint256 idx = uint8(indices[newIndex]);\n        require(\n            state[idx & IDX_VALUE_MASK].length == 32,\n            \"Array length must be 32 bytes\"\n        );\n        (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicTuple(\n            state,\n            indices,\n            dynamicLengths,\n            offsetIdx,\n            newCount,\n            newIndex\n        );\n    }\n\n    function setupDynamicTuple(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        uint256 idx;\n        uint256 offset;\n        newDynamicLengths = dynamicLengths;\n        // Progress to first index of the data and progress the next offset idx\n        unchecked {\n            newIndex = index + 1;\n            newOffsetIdx = offsetIdx + 1;\n            newCount = count + 32;\n        }\n        while (newIndex < 32) {\n            idx = uint8(indices[newIndex]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_DYNAMIC_END) {\n                    newDynamicLengths[offsetIdx] = offset;\n                    // explicit return saves gas ¯\\_(ツ)_/¯\n                    return (newDynamicLengths, newOffsetIdx, newCount, newIndex);\n                } else {\n                    require(idx != IDX_USE_STATE, \"Cannot use state from inside dynamic type\");\n                    (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicType(\n                        state,\n                        indices,\n                        newDynamicLengths,\n                        idx,\n                        newOffsetIdx,\n                        newCount,\n                        newIndex\n                    );\n                }\n            } else {\n                newCount = setupStaticVariable(state, newCount, idx);\n            }\n            unchecked {\n                offset += 32;\n                ++newIndex;\n            }\n        }\n        revert(\"Dynamic type was not properly closed\");\n    }\n\n    function encodeDynamicArray(\n        bytes memory ret,\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 currentSlot,\n        uint256 index\n    ) internal view returns (\n        uint256 newOffsetIdx,\n        uint256 newSlot,\n        uint256 newIndex,\n        uint256 length\n    ) {\n        // Progress to array length metadata\n        unchecked {\n            newIndex = index + 1;\n            newSlot = currentSlot + 32;\n        }\n        // Encode array length\n        uint256 idx = uint8(indices[newIndex]);\n        // Array length value previously checked to be 32 bytes\n        bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n        assembly {\n            mstore(add(add(ret, 36), currentSlot), mload(add(stateVar, 32)))\n        }\n        (newOffsetIdx, newSlot, newIndex, length) = encodeDynamicTuple(\n            ret,\n            state,\n            indices,\n            dynamicLengths,\n            offsetIdx,\n            newSlot,\n            newIndex\n        );\n        unchecked {\n            length += 32; // Increase length to account for array length metadata\n        }\n    }\n\n    function encodeDynamicTuple(\n        bytes memory ret,\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 currentSlot,\n        uint256 index\n    ) internal view returns (\n        uint256 newOffsetIdx,\n        uint256 newSlot,\n        uint256 newIndex,\n        uint256 length\n    ) {\n        uint256 idx;\n        uint256 argLen;\n        uint256 freePointer = dynamicLengths[offsetIdx]; // The pointer to the next free slot\n        unchecked {\n            newSlot = currentSlot + freePointer; // Update the next slot\n            newOffsetIdx = offsetIdx + 1; // Progress to next offsetIdx\n            newIndex = index + 1; // Progress to first index of the data\n        }\n        // Shift currentSlot to correct location in memory\n        assembly {\n            currentSlot := add(add(ret, 36), currentSlot)\n        }\n        while (newIndex < 32) {\n            idx = uint8(indices[newIndex]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_DYNAMIC_END) {\n                    break;\n                } else if (idx == IDX_ARRAY_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    (newOffsetIdx, newSlot, newIndex, argLen) = encodeDynamicArray(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        newOffsetIdx,\n                        newSlot,\n                        newIndex\n                    );\n                    unchecked {\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                } else if (idx == IDX_TUPLE_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    (newOffsetIdx, newSlot, newIndex, argLen) = encodeDynamicTuple(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        newOffsetIdx,\n                        newSlot,\n                        newIndex\n                    );\n                    unchecked {\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                } else  {\n                    // Variable length data\n                    argLen = state[idx & IDX_VALUE_MASK].length;\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    memcpy(\n                        state[idx & IDX_VALUE_MASK],\n                        0,\n                        ret,\n                        newSlot + 4,\n                        argLen\n                    );\n                    unchecked {\n                        newSlot += argLen;\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                }\n            } else {\n                // Fixed length data (length previously checked to be 32 bytes)\n                bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n                // Write to first free slot\n                assembly {\n                    mstore(currentSlot, mload(add(stateVar, 32)))\n                }\n                unchecked {\n                    length += 32;\n                }\n            }\n            unchecked {\n                currentSlot += 32;\n                ++newIndex;\n            }\n        }\n    }\n\n    function writeOutputs(\n        bytes[] memory state,\n        bytes1 index,\n        bytes memory output\n    ) internal pure returns (bytes[] memory) {\n        uint256 idx = uint8(index);\n        if (idx == IDX_END_OF_ARGS) return state;\n\n        if (idx & IDX_VARIABLE_LENGTH != 0) {\n            if (idx == IDX_USE_STATE) {\n                state = abi.decode(output, (bytes[]));\n            } else {\n                require(idx & IDX_VALUE_MASK < state.length, \"Index out-of-bounds\");\n                // Check the first field is 0x20 (because we have only a single return value)\n                uint256 argPtr;\n                assembly {\n                    argPtr := mload(add(output, 32))\n                }\n                require(\n                    argPtr == 32,\n                    \"Only one return value permitted (variable)\"\n                );\n\n                assembly {\n                    // Overwrite the first word of the return data with the length - 32\n                    mstore(add(output, 32), sub(mload(output), 32))\n                    // Insert a pointer to the return data, starting at the second word, into state\n                    mstore(\n                        add(add(state, 32), mul(and(idx, IDX_VALUE_MASK), 32)),\n                        add(output, 32)\n                    )\n                }\n            }\n        } else {\n            require(idx & IDX_VALUE_MASK < state.length, \"Index out-of-bounds\");\n            // Single word\n            require(\n                output.length == 32,\n                \"Only one return value permitted (static)\"\n            );\n\n            state[idx & IDX_VALUE_MASK] = output;\n        }\n\n        return state;\n    }\n\n    function writeTuple(\n        bytes[] memory state,\n        bytes1 index,\n        bytes memory output\n    ) internal view {\n        uint256 idx = uint8(index);\n        if (idx == IDX_END_OF_ARGS) return;\n\n        bytes memory entry = state[idx & IDX_VALUE_MASK] = new bytes(output.length + 32);\n        memcpy(output, 0, entry, 32, output.length);\n        assembly {\n            let l := mload(output)\n            mstore(add(entry, 32), l)\n        }\n    }\n\n    function memcpy(\n        bytes memory src,\n        uint256 srcIdx,\n        bytes memory dest,\n        uint256 destIdx,\n        uint256 len\n    ) internal view {\n        assembly {\n            pop(\n                staticcall(\n                    gas(),\n                    4,\n                    add(add(src, 32), srcIdx),\n                    len,\n                    add(add(dest, 32), destIdx),\n                    len\n                )\n            )\n        }\n    }\n}\n"},"lib/enso-weiroll/contracts/VM.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.16;\n\nimport \"./CommandBuilder.sol\";\n\nabstract contract VM {\n    using CommandBuilder for bytes[];\n\n    uint256 constant FLAG_CT_DELEGATECALL = 0x00; // Delegate call not currently supported\n    uint256 constant FLAG_CT_CALL = 0x01;\n    uint256 constant FLAG_CT_STATICCALL = 0x02;\n    uint256 constant FLAG_CT_VALUECALL = 0x03;\n    uint256 constant FLAG_CT_MASK = 0x03;\n    uint256 constant FLAG_DATA = 0x20;\n    uint256 constant FLAG_EXTENDED_COMMAND = 0x40;\n    uint256 constant FLAG_TUPLE_RETURN = 0x80;\n\n    uint256 constant SHORT_COMMAND_FILL =\n        0x000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;\n\n    error ExecutionFailed(\n        uint256 command_index,\n        address target,\n        string message\n    );\n\n    function _execute(bytes32[] calldata commands, bytes[] memory state)\n        internal\n        returns (bytes[] memory)\n    {\n        bytes32 command;\n        uint256 flags;\n        bytes32 indices;\n\n        bool success;\n        bytes memory outData;\n\n        uint256 commandsLength = commands.length;\n        uint256 indicesLength;\n        for (uint256 i; i < commandsLength; i = _uncheckedIncrement(i)) {\n            command = commands[i];\n            flags = uint256(uint8(bytes1(command << 32)));\n\n            if (flags & FLAG_EXTENDED_COMMAND != 0) {\n                i = _uncheckedIncrement(i);\n                indices = commands[i];\n                indicesLength = 32;\n            } else {\n                indices = bytes32(uint256(command << 40) | SHORT_COMMAND_FILL);\n                indicesLength = 6;\n            }\n\n            if (flags & FLAG_CT_MASK == FLAG_CT_CALL) {\n                (success, outData) = address(uint160(uint256(command))).call( // target\n                    // inputs\n                    flags & FLAG_DATA == 0\n                        ? state.buildInputs(\n                            bytes4(command), // selector\n                            indices,\n                            indicesLength\n                        )\n                        : state[\n                            uint8(bytes1(indices)) &\n                            CommandBuilder.IDX_VALUE_MASK\n                        ]\n                );\n            } else if (flags & FLAG_CT_MASK == FLAG_CT_STATICCALL) {\n                (success, outData) = address(uint160(uint256(command))) // target\n                    .staticcall(\n                        // inputs\n                        flags & FLAG_DATA == 0\n                            ? state.buildInputs(\n                                bytes4(command), // selector\n                                indices,\n                                indicesLength\n                            )\n                            : state[\n                                uint8(bytes1(indices)) &\n                                CommandBuilder.IDX_VALUE_MASK\n                            ]\n                    );\n            } else if (flags & FLAG_CT_MASK == FLAG_CT_VALUECALL) {\n                bytes memory v = state[\n                    uint8(bytes1(indices)) &\n                    CommandBuilder.IDX_VALUE_MASK\n                ];\n                require(v.length == 32, \"Value must be 32 bytes\");\n                uint256 callEth = uint256(bytes32(v));\n                (success, outData) = address(uint160(uint256(command))).call{ // target\n                    value: callEth\n                }(\n                    // inputs\n                    flags & FLAG_DATA == 0\n                        ? state.buildInputs(\n                            bytes4(command), // selector\n                            indices << 8, // skip value input\n                            indicesLength - 1 // max indices length reduced by value input\n                        )\n                        : state[\n                            uint8(bytes1(indices << 8)) & // first byte after value input\n                            CommandBuilder.IDX_VALUE_MASK\n                        ]\n                );\n            } else {\n                revert(\"Invalid calltype\");\n            }\n\n            if (!success) {\n                string memory message = \"Unknown\";\n                if (outData.length > 68) {\n                    // This might be an error message, parse the outData\n                    // Estimate the bytes length of the possible error message\n                    uint256 estimatedLength = _estimateBytesLength(outData, 68);\n                    // Remove selector. First 32 bytes should be a pointer that indicates the start of data in memory\n                    assembly {\n                        outData := add(outData, 4)\n                    }\n                    uint256 pointer = uint256(bytes32(outData));\n                    if (pointer == 32) {\n                        // Remove pointer. If it is a string, the next 32 bytes will hold the size\n                        assembly {\n                            outData := add(outData, 32)\n                        }\n                        uint256 size = uint256(bytes32(outData));\n                        // If the size variable is the same as the estimated bytes length, we can be fairly certain\n                        // this is a dynamic string, so convert the bytes to a string and emit the message. While an\n                        // error function with 3 static parameters is capable of producing a similar output, there is\n                        // low risk of a contract unintentionally emitting a message.\n                        if (size == estimatedLength) {\n                            // Remove size. The remaining data should be the string content\n                            assembly {\n                                outData := add(outData, 32)\n                            }\n                            message = string(outData);\n                        }\n                    }\n                }\n                revert ExecutionFailed({\n                    command_index: flags & FLAG_EXTENDED_COMMAND == 0\n                        ? i\n                        : i - 1,\n                    target: address(uint160(uint256(command))),\n                    message: message\n                });\n            }\n\n            if (flags & FLAG_TUPLE_RETURN != 0) {\n                state.writeTuple(bytes1(command << 88), outData);\n            } else {\n                state = state.writeOutputs(bytes1(command << 88), outData);\n            }\n        }\n        return state;\n    }\n\n    function _estimateBytesLength(bytes memory data, uint256 pos) internal pure returns (uint256 estimate) {\n        uint256 length = data.length;\n        estimate = length - pos; // Assume length equals alloted space\n        for (uint256 i = pos; i < length; ) {\n            if (data[i] == 0) {\n                // Zero bytes found, adjust estimated length\n                estimate = i - pos;\n                break;\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function _uncheckedIncrement(uint256 i) private pure returns (uint256) {\n        unchecked {\n            ++i;\n        }\n        return i;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Interface that must be implemented by smart contracts in order to receive\n * ERC-1155 token transfers.\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC-1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC-1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165, ERC165} from \"../../../utils/introspection/ERC165.sol\";\nimport {IERC1155Receiver} from \"../IERC1155Receiver.sol\";\n\n/**\n * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC-1155 tokens.\n *\n * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be\n * stuck.\n */\nabstract contract ERC1155Holder is ERC165, IERC1155Receiver {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155Received.selector;\n    }\n\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] memory,\n        uint256[] memory,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155BatchReceived.selector;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\n\n/**\n * @dev Implementation of the {IERC721Receiver} interface.\n *\n * Accepts all token transfers.\n * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or\n * {IERC721-setApprovalForAll}.\n */\nabstract contract ERC721Holder is IERC721Receiver {\n    /**\n     * @dev See {IERC721Receiver-onERC721Received}.\n     *\n     * Always returns `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\n        return this.onERC721Received.selector;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"lib/openzeppelin-contracts/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"},"src/AbstractEnsoShortcuts.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { VM } from \"enso-weiroll/VM.sol\";\nimport { ERC721Holder } from \"openzeppelin-contracts/token/ERC721/utils/ERC721Holder.sol\";\nimport { ERC1155Holder } from \"openzeppelin-contracts/token/ERC1155/utils/ERC1155Holder.sol\";\n\nabstract contract AbstractEnsoShortcuts is VM, ERC721Holder, ERC1155Holder {\n\n    event ShortcutExecuted(bytes32 accountId, bytes32 requestId);\n\n    // @notice Execute a shortcut\n    // @param accountId The bytes32 value representing an API user\n    // @param requestId The bytes32 value representing an API request\n    // @param commands An array of bytes32 values that encode calls\n    // @param state An array of bytes that are used to generate call data for each command\n    function executeShortcut(\n        bytes32 accountId,\n        bytes32 requestId,\n        bytes32[] calldata commands,\n        bytes[] calldata state\n    ) public virtual payable returns (bytes[] memory response) {\n        _checkMsgSender();\n        response = _execute(commands, state);\n        emit ShortcutExecuted(accountId, requestId);\n    }\n\n    //@notice Abstract function to validate msg.sender\n    function _checkMsgSender() internal virtual view;\n\n    receive() external virtual payable {}\n}"},"src/EnsoShortcuts.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { AbstractEnsoShortcuts } from \"./AbstractEnsoShortcuts.sol\";\n\ncontract EnsoShortcuts is AbstractEnsoShortcuts {\n    address immutable public executor;\n\n    error NotPermitted();\n\n    constructor(address executor_) {\n        executor = executor_;\n    }\n\n    function _checkMsgSender() internal override view {\n        if (msg.sender != executor) revert NotPermitted();\n    }\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@ensdomains/=lib/shortcuts-contracts/node_modules/@ensdomains/",":@ensofinance/=lib/shortcuts-contracts/node_modules/@ensofinance/",":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/",":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/",":@openzeppelin/=lib/shortcuts-contracts/node_modules/@openzeppelin/",":@rari-capital/=lib/shortcuts-contracts/node_modules/@rari-capital/",":@uniswap/v4-core/=lib/v4-core/",":@uniswap/v4-periphery/=lib/v4-periphery/",":clones-with-immutable-args/=lib/shortcuts-contracts/node_modules/clones-with-immutable-args/",":devtools/=lib/devtools/packages/toolbox-foundry/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":enso-weiroll/=lib/enso-weiroll/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":eth-gas-reporter/=lib/shortcuts-contracts/node_modules/eth-gas-reporter/",":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat-deploy/=lib/shortcuts-contracts/node_modules/hardhat-deploy/",":hardhat/=lib/shortcuts-contracts/node_modules/hardhat/",":layerzero-v2/=lib/layerzero-v2/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":permit2/=lib/v4-periphery/lib/permit2/",":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/",":safe-tools/=lib/safe-tools/src/",":shortcuts-contracts/=lib/shortcuts-contracts/contracts/",":solady/=lib/solady/src/",":solmate/=lib/solady/lib/solmate/src/",":v4-core/=lib/v4-core/src/",":v4-periphery/=lib/v4-periphery/"]},"name":"EnsoShortcuts","fullyQualifiedName":"src/EnsoShortcuts.sol:EnsoShortcuts"},"abi":[{"type":"constructor","inputs":[{"name":"executor_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ExecutionFailed","type":"error","inputs":[{"name":"command_index","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"message","type":"string","internalType":"string"}]},{"name":"NotPermitted","type":"error","inputs":[]},{"name":"ShortcutExecuted","type":"event","inputs":[{"name":"accountId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"requestId","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"name":"executeShortcut","type":"function","inputs":[{"name":"accountId","type":"bytes32","internalType":"bytes32"},{"name":"requestId","type":"bytes32","internalType":"bytes32"},{"name":"commands","type":"bytes32[]","internalType":"bytes32[]"},{"name":"state","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"response","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"payable"},{"name":"executor","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"onERC1155BatchReceived","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"onERC1155Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"onERC721Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"executor_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"command_index","type":"uint256"},{"internalType":"address","name":"target","type":"address"},{"internalType":"string","name":"message","type":"string"}],"name":"ExecutionFailed","type":"error"},{"inputs":[],"name":"NotPermitted","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"accountId","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"requestId","type":"bytes32"}],"name":"ShortcutExecuted","type":"event"},{"inputs":[{"internalType":"bytes32","name":"accountId","type":"bytes32"},{"internalType":"bytes32","name":"requestId","type":"bytes32"},{"internalType":"bytes32[]","name":"commands","type":"bytes32[]"},{"internalType":"bytes[]","name":"state","type":"bytes[]"}],"name":"executeShortcut","outputs":[{"internalType":"bytes[]","name":"response","type":"bytes[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"executor","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"kind":"dev","methods":{"onERC721Received(address,address,uint256,bytes)":{"details":"See {IERC721Receiver-onERC721Received}. Always returns `IERC721Receiver.onERC721Received.selector`."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"src/EnsoShortcuts.sol":"EnsoShortcuts"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@ensdomains/=lib/shortcuts-contracts/node_modules/@ensdomains/",":@ensofinance/=lib/shortcuts-contracts/node_modules/@ensofinance/",":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/",":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/",":@openzeppelin/=lib/shortcuts-contracts/node_modules/@openzeppelin/",":@rari-capital/=lib/shortcuts-contracts/node_modules/@rari-capital/",":@uniswap/v4-core/=lib/v4-core/",":@uniswap/v4-periphery/=lib/v4-periphery/",":clones-with-immutable-args/=lib/shortcuts-contracts/node_modules/clones-with-immutable-args/",":devtools/=lib/devtools/packages/toolbox-foundry/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":enso-weiroll/=lib/enso-weiroll/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":eth-gas-reporter/=lib/shortcuts-contracts/node_modules/eth-gas-reporter/",":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat-deploy/=lib/shortcuts-contracts/node_modules/hardhat-deploy/",":hardhat/=lib/shortcuts-contracts/node_modules/hardhat/",":layerzero-v2/=lib/layerzero-v2/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":permit2/=lib/v4-periphery/lib/permit2/",":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/",":safe-tools/=lib/safe-tools/src/",":shortcuts-contracts/=lib/shortcuts-contracts/contracts/",":solady/=lib/solady/src/",":solmate/=lib/solady/lib/solmate/src/",":v4-core/=lib/v4-core/src/",":v4-periphery/=lib/v4-periphery/"],"viaIR":true},"sources":{"lib/enso-weiroll/contracts/CommandBuilder.sol":{"keccak256":"0xd6f5e1f44b67c4bfd0f3578c998a6cbd0a936b5912d4dfd668291e01979c6aa3","license":"GPL-3.0-only","urls":["bzz-raw://c6b70fd8754628d6791bfa4898fbc183c71ba872b9a3576ec0723b80049fecb2","dweb:/ipfs/QmTox4XhyKywB9bGwxSFW1KUtwGqbbqpuXvXmjESZX8wLG"]},"lib/enso-weiroll/contracts/VM.sol":{"keccak256":"0x82074b35c073aac1d4ecabf0d76cdeb597248dc9f9030ca197f4a119941670fe","license":"GPL-3.0-only","urls":["bzz-raw://efc06c9c1ab8657d5b4493ffb28ffbb2de931f187626cd19c4475f236c6c9164","dweb:/ipfs/QmVnSVZHu7Hwgd4bjTfCoedHd7XnbNiF6QRr2PwE5UeNgm"]},"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol":{"keccak256":"0x61a23d601c2ab69dd726ac55058604cbda98e1d728ba31a51c379a3f9eeea715","license":"MIT","urls":["bzz-raw://d8cbb06152d82ebdd5ba1d33454e5759492040f309a82637c7e99c948a04fa20","dweb:/ipfs/QmQQuLr6WSfLu97pMEh6XLefk99TSj9k5Qu1zXGPepwGiK"]},"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol":{"keccak256":"0xe103e95f854ef0cd1bba5f469175f67cd332f5c2561941f165e3dd65cee94d6d","license":"MIT","urls":["bzz-raw://6cf8cc5d07cf8003255f9d766fe8188b9f6e33b6240e126a605f0d061566b23e","dweb:/ipfs/Qmd7okDCSoUt1L4G9hmb5c4W8kWUnfpAa2jyBKUp4xKErd"]},"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol":{"keccak256":"0xb5afb8e8eebc4d1c6404df2f5e1e6d2c3d24fd01e5dfc855314951ecfaae462d","license":"MIT","urls":["bzz-raw://78586466c424f076c6a2a551d848cfbe3f7c49e723830807598484a1047b3b34","dweb:/ipfs/Qmb717ovcFxm7qgNKEShiV6M9SPR3v1qnNpAGH84D6w29p"]},"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol":{"keccak256":"0xaad20f8713b5cd98114278482d5d91b9758f9727048527d582e8e88fd4901fd8","license":"MIT","urls":["bzz-raw://5396e8dbb000c2fada59b7d2093b9c7c870fd09413ab0fdaba45d882959c6244","dweb:/ipfs/QmXQn5XckSiUsUBpMYuiFeqnojRX4rKa9jmgjCPeTuPmhh"]},"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol":{"keccak256":"0xddce8e17e3d3f9ed818b4f4c4478a8262aab8b11ed322f1bf5ed705bb4bd97fa","license":"MIT","urls":["bzz-raw://8084aa71a4cc7d2980972412a88fe4f114869faea3fefa5436431644eb5c0287","dweb:/ipfs/Qmbqfs5dRdPvHVKY8kTaeyc65NdqXRQwRK7h9s5UJEhD1p"]},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8","license":"MIT","urls":["bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621","dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL"]},"src/AbstractEnsoShortcuts.sol":{"keccak256":"0x13d1f02f59cb1eaa7fa5867c490c3424ba140b060c9d3f1726ea886259f61eec","license":"GPL-3.0-only","urls":["bzz-raw://f4b0824a7235e4fe94c81ddfc0c87ecb9b2f65a347267dde1c3e01771ed217ae","dweb:/ipfs/QmcZSJXGvnr7csVJySJbyMzRjHgDC6NGo3ozWWNdccJtVK"]},"src/EnsoShortcuts.sol":{"keccak256":"0x0eb8687d49d7d069ac3d88476913d6bc061756b6b0285165eeccf3ec6c4c538e","license":"GPL-3.0-only","urls":["bzz-raw://4a255f8ac6a4b11b7b9951d85ae1a351cd2b99285ff7c4e1a1f640e2ce0b5644","dweb:/ipfs/QmT3xkize31ZhrGvwuQTxd8jutVAoH898Woq5hfsZtwJMZ"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"onERC721Received(address,address,uint256,bytes)":{"details":"See {IERC721Receiver-onERC721Received}. Always returns `IERC721Receiver.onERC721Received.selector`."}},"version":1},"sourceIds":{"src/EnsoShortcuts.sol":{"id":9},"src/AbstractEnsoShortcuts.sol":{"id":8},"lib/enso-weiroll/contracts/VM.sol":{"id":1},"lib/enso-weiroll/contracts/CommandBuilder.sol":{"id":0},"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol":{"id":6},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":7},"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol":{"id":5},"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"src/EnsoShortcuts.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { AbstractEnsoShortcuts } from \"./AbstractEnsoShortcuts.sol\";\n\ncontract EnsoShortcuts is AbstractEnsoShortcuts {\n    address immutable public executor;\n\n    error NotPermitted();\n\n    constructor(address executor_) {\n        executor = executor_;\n    }\n\n    function _checkMsgSender() internal override view {\n        if (msg.sender != executor) revert NotPermitted();\n    }\n}"},"src/AbstractEnsoShortcuts.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\npragma solidity ^0.8.28;\n\nimport { VM } from \"enso-weiroll/VM.sol\";\nimport { ERC721Holder } from \"openzeppelin-contracts/token/ERC721/utils/ERC721Holder.sol\";\nimport { ERC1155Holder } from \"openzeppelin-contracts/token/ERC1155/utils/ERC1155Holder.sol\";\n\nabstract contract AbstractEnsoShortcuts is VM, ERC721Holder, ERC1155Holder {\n\n    event ShortcutExecuted(bytes32 accountId, bytes32 requestId);\n\n    // @notice Execute a shortcut\n    // @param accountId The bytes32 value representing an API user\n    // @param requestId The bytes32 value representing an API request\n    // @param commands An array of bytes32 values that encode calls\n    // @param state An array of bytes that are used to generate call data for each command\n    function executeShortcut(\n        bytes32 accountId,\n        bytes32 requestId,\n        bytes32[] calldata commands,\n        bytes[] calldata state\n    ) public virtual payable returns (bytes[] memory response) {\n        _checkMsgSender();\n        response = _execute(commands, state);\n        emit ShortcutExecuted(accountId, requestId);\n    }\n\n    //@notice Abstract function to validate msg.sender\n    function _checkMsgSender() internal virtual view;\n\n    receive() external virtual payable {}\n}"},"lib/enso-weiroll/contracts/VM.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.16;\n\nimport \"./CommandBuilder.sol\";\n\nabstract contract VM {\n    using CommandBuilder for bytes[];\n\n    uint256 constant FLAG_CT_DELEGATECALL = 0x00; // Delegate call not currently supported\n    uint256 constant FLAG_CT_CALL = 0x01;\n    uint256 constant FLAG_CT_STATICCALL = 0x02;\n    uint256 constant FLAG_CT_VALUECALL = 0x03;\n    uint256 constant FLAG_CT_MASK = 0x03;\n    uint256 constant FLAG_DATA = 0x20;\n    uint256 constant FLAG_EXTENDED_COMMAND = 0x40;\n    uint256 constant FLAG_TUPLE_RETURN = 0x80;\n\n    uint256 constant SHORT_COMMAND_FILL =\n        0x000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;\n\n    error ExecutionFailed(\n        uint256 command_index,\n        address target,\n        string message\n    );\n\n    function _execute(bytes32[] calldata commands, bytes[] memory state)\n        internal\n        returns (bytes[] memory)\n    {\n        bytes32 command;\n        uint256 flags;\n        bytes32 indices;\n\n        bool success;\n        bytes memory outData;\n\n        uint256 commandsLength = commands.length;\n        uint256 indicesLength;\n        for (uint256 i; i < commandsLength; i = _uncheckedIncrement(i)) {\n            command = commands[i];\n            flags = uint256(uint8(bytes1(command << 32)));\n\n            if (flags & FLAG_EXTENDED_COMMAND != 0) {\n                i = _uncheckedIncrement(i);\n                indices = commands[i];\n                indicesLength = 32;\n            } else {\n                indices = bytes32(uint256(command << 40) | SHORT_COMMAND_FILL);\n                indicesLength = 6;\n            }\n\n            if (flags & FLAG_CT_MASK == FLAG_CT_CALL) {\n                (success, outData) = address(uint160(uint256(command))).call( // target\n                    // inputs\n                    flags & FLAG_DATA == 0\n                        ? state.buildInputs(\n                            bytes4(command), // selector\n                            indices,\n                            indicesLength\n                        )\n                        : state[\n                            uint8(bytes1(indices)) &\n                            CommandBuilder.IDX_VALUE_MASK\n                        ]\n                );\n            } else if (flags & FLAG_CT_MASK == FLAG_CT_STATICCALL) {\n                (success, outData) = address(uint160(uint256(command))) // target\n                    .staticcall(\n                        // inputs\n                        flags & FLAG_DATA == 0\n                            ? state.buildInputs(\n                                bytes4(command), // selector\n                                indices,\n                                indicesLength\n                            )\n                            : state[\n                                uint8(bytes1(indices)) &\n                                CommandBuilder.IDX_VALUE_MASK\n                            ]\n                    );\n            } else if (flags & FLAG_CT_MASK == FLAG_CT_VALUECALL) {\n                bytes memory v = state[\n                    uint8(bytes1(indices)) &\n                    CommandBuilder.IDX_VALUE_MASK\n                ];\n                require(v.length == 32, \"Value must be 32 bytes\");\n                uint256 callEth = uint256(bytes32(v));\n                (success, outData) = address(uint160(uint256(command))).call{ // target\n                    value: callEth\n                }(\n                    // inputs\n                    flags & FLAG_DATA == 0\n                        ? state.buildInputs(\n                            bytes4(command), // selector\n                            indices << 8, // skip value input\n                            indicesLength - 1 // max indices length reduced by value input\n                        )\n                        : state[\n                            uint8(bytes1(indices << 8)) & // first byte after value input\n                            CommandBuilder.IDX_VALUE_MASK\n                        ]\n                );\n            } else {\n                revert(\"Invalid calltype\");\n            }\n\n            if (!success) {\n                string memory message = \"Unknown\";\n                if (outData.length > 68) {\n                    // This might be an error message, parse the outData\n                    // Estimate the bytes length of the possible error message\n                    uint256 estimatedLength = _estimateBytesLength(outData, 68);\n                    // Remove selector. First 32 bytes should be a pointer that indicates the start of data in memory\n                    assembly {\n                        outData := add(outData, 4)\n                    }\n                    uint256 pointer = uint256(bytes32(outData));\n                    if (pointer == 32) {\n                        // Remove pointer. If it is a string, the next 32 bytes will hold the size\n                        assembly {\n                            outData := add(outData, 32)\n                        }\n                        uint256 size = uint256(bytes32(outData));\n                        // If the size variable is the same as the estimated bytes length, we can be fairly certain\n                        // this is a dynamic string, so convert the bytes to a string and emit the message. While an\n                        // error function with 3 static parameters is capable of producing a similar output, there is\n                        // low risk of a contract unintentionally emitting a message.\n                        if (size == estimatedLength) {\n                            // Remove size. The remaining data should be the string content\n                            assembly {\n                                outData := add(outData, 32)\n                            }\n                            message = string(outData);\n                        }\n                    }\n                }\n                revert ExecutionFailed({\n                    command_index: flags & FLAG_EXTENDED_COMMAND == 0\n                        ? i\n                        : i - 1,\n                    target: address(uint160(uint256(command))),\n                    message: message\n                });\n            }\n\n            if (flags & FLAG_TUPLE_RETURN != 0) {\n                state.writeTuple(bytes1(command << 88), outData);\n            } else {\n                state = state.writeOutputs(bytes1(command << 88), outData);\n            }\n        }\n        return state;\n    }\n\n    function _estimateBytesLength(bytes memory data, uint256 pos) internal pure returns (uint256 estimate) {\n        uint256 length = data.length;\n        estimate = length - pos; // Assume length equals alloted space\n        for (uint256 i = pos; i < length; ) {\n            if (data[i] == 0) {\n                // Zero bytes found, adjust estimated length\n                estimate = i - pos;\n                break;\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function _uncheckedIncrement(uint256 i) private pure returns (uint256) {\n        unchecked {\n            ++i;\n        }\n        return i;\n    }\n}\n"},"lib/enso-weiroll/contracts/CommandBuilder.sol":{"content":"// SPDX-License-Identifier: GPL-3.0-only\n\npragma solidity ^0.8.16;\n\nlibrary CommandBuilder {\n    uint256 constant IDX_VARIABLE_LENGTH = 0x80;\n    uint256 constant IDX_VALUE_MASK = 0x7f;\n    uint256 constant IDX_END_OF_ARGS = 0xff;\n    uint256 constant IDX_USE_STATE = 0xfe;\n    uint256 constant IDX_ARRAY_START = 0xfd;\n    uint256 constant IDX_TUPLE_START = 0xfc;\n    uint256 constant IDX_DYNAMIC_END = 0xfb;\n\n    function buildInputs(\n        bytes[] memory state,\n        bytes4 selector,\n        bytes32 indices,\n        uint256 indicesLength\n    ) internal view returns (bytes memory ret) {\n        uint256 idx; // The current command index\n        uint256 offsetIdx; // The index of the current free offset\n\n        uint256 count; // Number of bytes in whole ABI encoded message\n        uint256 free; // Pointer to first free byte in tail part of message\n        uint256[] memory dynamicLengths = new uint256[](10); // Optionally store the length of all dynamic types (a command cannot fit more than 10 dynamic types)\n\n        bytes memory stateData; // Optionally encode the current state if the call requires it\n\n        // Determine the length of the encoded data\n        for (uint256 i; i < indicesLength; ) {\n            idx = uint8(indices[i]);\n            if (idx == IDX_END_OF_ARGS) {\n                indicesLength = i;\n                break;\n            }\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_USE_STATE) {\n                    if (stateData.length == 0) {\n                        stateData = abi.encode(state);\n                    }\n                    unchecked {\n                        count += stateData.length;\n                    }\n                } else {\n                    (dynamicLengths, offsetIdx, count, i) = setupDynamicType(\n                        state,\n                        indices,\n                        dynamicLengths,\n                        idx,\n                        offsetIdx,\n                        count,\n                        i\n                    );\n                }\n            } else {\n                count = setupStaticVariable(state, count, idx);\n            }\n            unchecked {\n                free += 32;\n                ++i;\n            }\n        }\n\n        // Encode it\n        ret = new bytes(count + 4);\n        assembly {\n            mstore(add(ret, 32), selector)\n        }\n        offsetIdx = 0;\n        // Use count to track current memory slot\n        assembly {\n            count := add(ret, 36)\n        }\n        for (uint256 i; i < indicesLength; ) {\n            idx = uint8(indices[i]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_USE_STATE) {\n                    assembly {\n                        mstore(count, free)\n                    }\n                    memcpy(stateData, 32, ret, free + 4, stateData.length - 32);\n                    unchecked {\n                        free += stateData.length - 32;\n                    }\n                } else if (idx == IDX_ARRAY_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    (offsetIdx, free, i, ) = encodeDynamicArray(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        offsetIdx,\n                        free,\n                        i\n                    );\n                } else if (idx == IDX_TUPLE_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    (offsetIdx, free, i, ) = encodeDynamicTuple(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        offsetIdx,\n                        free,\n                        i\n                    );\n                } else {\n                    // Variable length data\n                    uint256 argLen = state[idx & IDX_VALUE_MASK].length;\n                    // Put a pointer in the current slot and write the data to first free slot\n                    assembly {\n                        mstore(count, free)\n                    }\n                    memcpy(\n                        state[idx & IDX_VALUE_MASK],\n                        0,\n                        ret,\n                        free + 4,\n                        argLen\n                    );\n                    unchecked {\n                        free += argLen;\n                    }\n                }\n            } else {\n                // Fixed length data (length previously checked to be 32 bytes)\n                bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n                // Write the data to current slot\n                assembly {\n                    mstore(count, mload(add(stateVar, 32)))\n                }\n            }\n            unchecked {\n                count += 32;\n                ++i;\n            }\n        }\n    }\n\n    function setupStaticVariable(\n        bytes[] memory state,\n        uint256 count,\n        uint256 idx\n    ) internal pure returns (uint256 newCount) {\n        require(\n            state[idx & IDX_VALUE_MASK].length == 32,\n            \"Static state variables must be 32 bytes\"\n        );\n        unchecked {\n            newCount = count + 32;\n        }\n    }\n\n    function setupDynamicVariable(\n        bytes[] memory state,\n        uint256 count,\n        uint256 idx\n    ) internal pure returns (uint256 newCount) {\n        bytes memory arg = state[idx & IDX_VALUE_MASK];\n        // Validate the length of the data in state is a multiple of 32\n        uint256 argLen = arg.length;\n        require(\n            argLen != 0 && argLen % 32 == 0,\n            \"Dynamic state variables must be a multiple of 32 bytes\"\n        );\n        // Add the length of the value, rounded up to the next word boundary, plus space for pointer\n        unchecked {\n            newCount = count + argLen + 32;\n        }\n    }\n\n    function setupDynamicType(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 idx,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        if (idx == IDX_ARRAY_START) {\n            (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicArray(\n                state,\n                indices,\n                dynamicLengths,\n                offsetIdx,\n                count,\n                index\n            );\n        } else if (idx == IDX_TUPLE_START) {\n            (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicTuple(\n                state,\n                indices,\n                dynamicLengths,\n                offsetIdx,\n                count,\n                index\n            );\n        } else {\n            newDynamicLengths = dynamicLengths;\n            newOffsetIdx = offsetIdx;\n            newIndex = index;\n            newCount = setupDynamicVariable(state, count, idx);\n        }\n    }\n\n    function setupDynamicArray(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        // Current idx is IDX_ARRAY_START, next idx will contain the array length\n        unchecked {\n            newIndex = index + 1;\n            newCount = count + 32;\n        }\n        uint256 idx = uint8(indices[newIndex]);\n        require(\n            state[idx & IDX_VALUE_MASK].length == 32,\n            \"Array length must be 32 bytes\"\n        );\n        (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicTuple(\n            state,\n            indices,\n            dynamicLengths,\n            offsetIdx,\n            newCount,\n            newIndex\n        );\n    }\n\n    function setupDynamicTuple(\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 count,\n        uint256 index\n    ) internal view returns (\n        uint256[] memory newDynamicLengths,\n        uint256 newOffsetIdx,\n        uint256 newCount,\n        uint256 newIndex\n    ) {\n        uint256 idx;\n        uint256 offset;\n        newDynamicLengths = dynamicLengths;\n        // Progress to first index of the data and progress the next offset idx\n        unchecked {\n            newIndex = index + 1;\n            newOffsetIdx = offsetIdx + 1;\n            newCount = count + 32;\n        }\n        while (newIndex < 32) {\n            idx = uint8(indices[newIndex]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_DYNAMIC_END) {\n                    newDynamicLengths[offsetIdx] = offset;\n                    // explicit return saves gas ¯\\_(ツ)_/¯\n                    return (newDynamicLengths, newOffsetIdx, newCount, newIndex);\n                } else {\n                    require(idx != IDX_USE_STATE, \"Cannot use state from inside dynamic type\");\n                    (newDynamicLengths, newOffsetIdx, newCount, newIndex) = setupDynamicType(\n                        state,\n                        indices,\n                        newDynamicLengths,\n                        idx,\n                        newOffsetIdx,\n                        newCount,\n                        newIndex\n                    );\n                }\n            } else {\n                newCount = setupStaticVariable(state, newCount, idx);\n            }\n            unchecked {\n                offset += 32;\n                ++newIndex;\n            }\n        }\n        revert(\"Dynamic type was not properly closed\");\n    }\n\n    function encodeDynamicArray(\n        bytes memory ret,\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 currentSlot,\n        uint256 index\n    ) internal view returns (\n        uint256 newOffsetIdx,\n        uint256 newSlot,\n        uint256 newIndex,\n        uint256 length\n    ) {\n        // Progress to array length metadata\n        unchecked {\n            newIndex = index + 1;\n            newSlot = currentSlot + 32;\n        }\n        // Encode array length\n        uint256 idx = uint8(indices[newIndex]);\n        // Array length value previously checked to be 32 bytes\n        bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n        assembly {\n            mstore(add(add(ret, 36), currentSlot), mload(add(stateVar, 32)))\n        }\n        (newOffsetIdx, newSlot, newIndex, length) = encodeDynamicTuple(\n            ret,\n            state,\n            indices,\n            dynamicLengths,\n            offsetIdx,\n            newSlot,\n            newIndex\n        );\n        unchecked {\n            length += 32; // Increase length to account for array length metadata\n        }\n    }\n\n    function encodeDynamicTuple(\n        bytes memory ret,\n        bytes[] memory state,\n        bytes32 indices,\n        uint256[] memory dynamicLengths,\n        uint256 offsetIdx,\n        uint256 currentSlot,\n        uint256 index\n    ) internal view returns (\n        uint256 newOffsetIdx,\n        uint256 newSlot,\n        uint256 newIndex,\n        uint256 length\n    ) {\n        uint256 idx;\n        uint256 argLen;\n        uint256 freePointer = dynamicLengths[offsetIdx]; // The pointer to the next free slot\n        unchecked {\n            newSlot = currentSlot + freePointer; // Update the next slot\n            newOffsetIdx = offsetIdx + 1; // Progress to next offsetIdx\n            newIndex = index + 1; // Progress to first index of the data\n        }\n        // Shift currentSlot to correct location in memory\n        assembly {\n            currentSlot := add(add(ret, 36), currentSlot)\n        }\n        while (newIndex < 32) {\n            idx = uint8(indices[newIndex]);\n            if (idx & IDX_VARIABLE_LENGTH != 0) {\n                if (idx == IDX_DYNAMIC_END) {\n                    break;\n                } else if (idx == IDX_ARRAY_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    (newOffsetIdx, newSlot, newIndex, argLen) = encodeDynamicArray(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        newOffsetIdx,\n                        newSlot,\n                        newIndex\n                    );\n                    unchecked {\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                } else if (idx == IDX_TUPLE_START) {\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    (newOffsetIdx, newSlot, newIndex, argLen) = encodeDynamicTuple(\n                        ret,\n                        state,\n                        indices,\n                        dynamicLengths,\n                        newOffsetIdx,\n                        newSlot,\n                        newIndex\n                    );\n                    unchecked {\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                } else  {\n                    // Variable length data\n                    argLen = state[idx & IDX_VALUE_MASK].length;\n                    // Start of dynamic type, put pointer in current slot\n                    assembly {\n                        mstore(currentSlot, freePointer)\n                    }\n                    memcpy(\n                        state[idx & IDX_VALUE_MASK],\n                        0,\n                        ret,\n                        newSlot + 4,\n                        argLen\n                    );\n                    unchecked {\n                        newSlot += argLen;\n                        freePointer += argLen;\n                        length += (argLen + 32); // data + pointer\n                    }\n                }\n            } else {\n                // Fixed length data (length previously checked to be 32 bytes)\n                bytes memory stateVar = state[idx & IDX_VALUE_MASK];\n                // Write to first free slot\n                assembly {\n                    mstore(currentSlot, mload(add(stateVar, 32)))\n                }\n                unchecked {\n                    length += 32;\n                }\n            }\n            unchecked {\n                currentSlot += 32;\n                ++newIndex;\n            }\n        }\n    }\n\n    function writeOutputs(\n        bytes[] memory state,\n        bytes1 index,\n        bytes memory output\n    ) internal pure returns (bytes[] memory) {\n        uint256 idx = uint8(index);\n        if (idx == IDX_END_OF_ARGS) return state;\n\n        if (idx & IDX_VARIABLE_LENGTH != 0) {\n            if (idx == IDX_USE_STATE) {\n                state = abi.decode(output, (bytes[]));\n            } else {\n                require(idx & IDX_VALUE_MASK < state.length, \"Index out-of-bounds\");\n                // Check the first field is 0x20 (because we have only a single return value)\n                uint256 argPtr;\n                assembly {\n                    argPtr := mload(add(output, 32))\n                }\n                require(\n                    argPtr == 32,\n                    \"Only one return value permitted (variable)\"\n                );\n\n                assembly {\n                    // Overwrite the first word of the return data with the length - 32\n                    mstore(add(output, 32), sub(mload(output), 32))\n                    // Insert a pointer to the return data, starting at the second word, into state\n                    mstore(\n                        add(add(state, 32), mul(and(idx, IDX_VALUE_MASK), 32)),\n                        add(output, 32)\n                    )\n                }\n            }\n        } else {\n            require(idx & IDX_VALUE_MASK < state.length, \"Index out-of-bounds\");\n            // Single word\n            require(\n                output.length == 32,\n                \"Only one return value permitted (static)\"\n            );\n\n            state[idx & IDX_VALUE_MASK] = output;\n        }\n\n        return state;\n    }\n\n    function writeTuple(\n        bytes[] memory state,\n        bytes1 index,\n        bytes memory output\n    ) internal view {\n        uint256 idx = uint8(index);\n        if (idx == IDX_END_OF_ARGS) return;\n\n        bytes memory entry = state[idx & IDX_VALUE_MASK] = new bytes(output.length + 32);\n        memcpy(output, 0, entry, 32, output.length);\n        assembly {\n            let l := mload(output)\n            mstore(add(entry, 32), l)\n        }\n    }\n\n    function memcpy(\n        bytes memory src,\n        uint256 srcIdx,\n        bytes memory dest,\n        uint256 destIdx,\n        uint256 len\n    ) internal view {\n        assembly {\n            pop(\n                staticcall(\n                    gas(),\n                    4,\n                    add(add(src, 32), srcIdx),\n                    len,\n                    add(add(dest, 32), destIdx),\n                    len\n                )\n            )\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"},"lib/openzeppelin-contracts/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"},"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @title ERC-721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC-721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be\n     * reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165} from \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Interface that must be implemented by smart contracts in order to receive\n * ERC-1155 token transfers.\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC-1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC-1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC721Receiver} from \"../IERC721Receiver.sol\";\n\n/**\n * @dev Implementation of the {IERC721Receiver} interface.\n *\n * Accepts all token transfers.\n * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or\n * {IERC721-setApprovalForAll}.\n */\nabstract contract ERC721Holder is IERC721Receiver {\n    /**\n     * @dev See {IERC721Receiver-onERC721Received}.\n     *\n     * Always returns `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) {\n        return this.onERC721Received.selector;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Holder.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC165, ERC165} from \"../../../utils/introspection/ERC165.sol\";\nimport {IERC1155Receiver} from \"../IERC1155Receiver.sol\";\n\n/**\n * @dev Simple implementation of `IERC1155Receiver` that will allow a contract to hold ERC-1155 tokens.\n *\n * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be\n * stuck.\n */\nabstract contract ERC1155Holder is ERC165, IERC1155Receiver {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    function onERC1155Received(\n        address,\n        address,\n        uint256,\n        uint256,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155Received.selector;\n    }\n\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] memory,\n        uint256[] memory,\n        bytes memory\n    ) public virtual override returns (bytes4) {\n        return this.onERC1155BatchReceived.selector;\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[":@ensdomains/=lib/shortcuts-contracts/node_modules/@ensdomains/",":@ensofinance/=lib/shortcuts-contracts/node_modules/@ensofinance/",":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/",":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/",":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/",":@openzeppelin/=lib/shortcuts-contracts/node_modules/@openzeppelin/",":@rari-capital/=lib/shortcuts-contracts/node_modules/@rari-capital/",":@uniswap/v4-core/=lib/v4-core/",":@uniswap/v4-periphery/=lib/v4-periphery/",":clones-with-immutable-args/=lib/shortcuts-contracts/node_modules/clones-with-immutable-args/",":devtools/=lib/devtools/packages/toolbox-foundry/src/",":ds-test/=lib/forge-std/lib/ds-test/src/",":enso-weiroll/=lib/enso-weiroll/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":eth-gas-reporter/=lib/shortcuts-contracts/node_modules/eth-gas-reporter/",":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat-deploy/=lib/shortcuts-contracts/node_modules/hardhat-deploy/",":hardhat/=lib/shortcuts-contracts/node_modules/hardhat/",":layerzero-v2/=lib/layerzero-v2/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",":permit2/=lib/v4-periphery/lib/permit2/",":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/",":safe-tools/=lib/safe-tools/src/",":shortcuts-contracts/=lib/shortcuts-contracts/contracts/",":solady/=lib/solady/src/",":solmate/=lib/solady/lib/solmate/src/",":v4-core/=lib/v4-core/src/",":v4-periphery/=lib/v4-periphery/"]}},"stdJsonOutput":{"sources":{"src/EnsoShortcuts.sol":{"id":9},"src/AbstractEnsoShortcuts.sol":{"id":8},"lib/enso-weiroll/contracts/VM.sol":{"id":1},"lib/enso-weiroll/contracts/CommandBuilder.sol":{"id":0},"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol":{"id":6},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":7},"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol":{"id":4},"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol":{"id":5},"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol":{"id":3}},"contracts":{"src/EnsoShortcuts.sol":{"EnsoShortcuts":{"abi":[{"type":"constructor","inputs":[{"name":"executor_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"ExecutionFailed","type":"error","inputs":[{"name":"command_index","type":"uint256","internalType":"uint256"},{"name":"target","type":"address","internalType":"address"},{"name":"message","type":"string","internalType":"string"}]},{"name":"NotPermitted","type":"error","inputs":[]},{"name":"ShortcutExecuted","type":"event","inputs":[{"name":"accountId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"requestId","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"name":"executeShortcut","type":"function","inputs":[{"name":"accountId","type":"bytes32","internalType":"bytes32"},{"name":"requestId","type":"bytes32","internalType":"bytes32"},{"name":"commands","type":"bytes32[]","internalType":"bytes32[]"},{"name":"state","type":"bytes[]","internalType":"bytes[]"}],"outputs":[{"name":"response","type":"bytes[]","internalType":"bytes[]"}],"stateMutability":"payable"},{"name":"executor","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"onERC1155BatchReceived","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"uint256[]","internalType":"uint256[]"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"onERC1155Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"onERC721Received","type":"function","inputs":[{"name":"","type":"address","internalType":"address"},{"name":"","type":"address","internalType":"address"},{"name":"","type":"uint256","internalType":"uint256"},{"name":"","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"","type":"bytes4","internalType":"bytes4"}],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"executor_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"command_index\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"string\",\"name\":\"message\",\"type\":\"string\"}],\"name\":\"ExecutionFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotPermitted\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"accountId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"requestId\",\"type\":\"bytes32\"}],\"name\":\"ShortcutExecuted\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"accountId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"requestId\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32[]\",\"name\":\"commands\",\"type\":\"bytes32[]\"},{\"internalType\":\"bytes[]\",\"name\":\"state\",\"type\":\"bytes[]\"}],\"name\":\"executeShortcut\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"response\",\"type\":\"bytes[]\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"executor\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155BatchReceived\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC1155Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"name\":\"onERC721Received\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"onERC721Received(address,address,uint256,bytes)\":{\"details\":\"See {IERC721Receiver-onERC721Received}. Always returns `IERC721Receiver.onERC721Received.selector`.\"},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/EnsoShortcuts.sol\":\"EnsoShortcuts\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@ensdomains/=lib/shortcuts-contracts/node_modules/@ensdomains/\",\":@ensofinance/=lib/shortcuts-contracts/node_modules/@ensofinance/\",\":@layerzerolabs/lz-evm-oapp-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/oapp/\",\":@layerzerolabs/lz-evm-protocol-v2/=lib/layerzero-v2/packages/layerzero-v2/evm/protocol/\",\":@layerzerolabs/oapp-evm/=lib/devtools/packages/oapp-evm/\",\":@openzeppelin/=lib/shortcuts-contracts/node_modules/@openzeppelin/\",\":@rari-capital/=lib/shortcuts-contracts/node_modules/@rari-capital/\",\":@uniswap/v4-core/=lib/v4-core/\",\":@uniswap/v4-periphery/=lib/v4-periphery/\",\":clones-with-immutable-args/=lib/shortcuts-contracts/node_modules/clones-with-immutable-args/\",\":devtools/=lib/devtools/packages/toolbox-foundry/src/\",\":ds-test/=lib/forge-std/lib/ds-test/src/\",\":enso-weiroll/=lib/enso-weiroll/contracts/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":eth-gas-reporter/=lib/shortcuts-contracts/node_modules/eth-gas-reporter/\",\":forge-gas-snapshot/=lib/v4-periphery/lib/permit2/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":hardhat-deploy/=lib/shortcuts-contracts/node_modules/hardhat-deploy/\",\":hardhat/=lib/shortcuts-contracts/node_modules/hardhat/\",\":layerzero-v2/=lib/layerzero-v2/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/\",\":permit2/=lib/v4-periphery/lib/permit2/\",\":safe-contracts/=lib/safe-tools/lib/safe-contracts/contracts/\",\":safe-tools/=lib/safe-tools/src/\",\":shortcuts-contracts/=lib/shortcuts-contracts/contracts/\",\":solady/=lib/solady/src/\",\":solmate/=lib/solady/lib/solmate/src/\",\":v4-core/=lib/v4-core/src/\",\":v4-periphery/=lib/v4-periphery/\"],\"viaIR\":true},\"sources\":{\"lib/enso-weiroll/contracts/CommandBuilder.sol\":{\"keccak256\":\"0xd6f5e1f44b67c4bfd0f3578c998a6cbd0a936b5912d4dfd668291e01979c6aa3\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://c6b70fd8754628d6791bfa4898fbc183c71ba872b9a3576ec0723b80049fecb2\",\"dweb:/ipfs/QmTox4XhyKywB9bGwxSFW1KUtwGqbbqpuXvXmjESZX8wLG\"]},\"lib/enso-weiroll/contracts/VM.sol\":{\"keccak256\":\"0x82074b35c073aac1d4ecabf0d76cdeb597248dc9f9030ca197f4a119941670fe\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://efc06c9c1ab8657d5b4493ffb28ffbb2de931f187626cd19c4475f236c6c9164\",\"dweb:/ipfs/QmVnSVZHu7Hwgd4bjTfCoedHd7XnbNiF6QRr2PwE5UeNgm\"]},\"lib/openzeppelin-contracts/contracts/token/ERC1155/IERC1155Receiver.sol\":{\"keccak256\":\"0x61a23d601c2ab69dd726ac55058604cbda98e1d728ba31a51c379a3f9eeea715\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d8cbb06152d82ebdd5ba1d33454e5759492040f309a82637c7e99c948a04fa20\",\"dweb:/ipfs/QmQQuLr6WSfLu97pMEh6XLefk99TSj9k5Qu1zXGPepwGiK\"]},\"lib/openzeppelin-contracts/contracts/token/ERC1155/utils/ERC1155Holder.sol\":{\"keccak256\":\"0xe103e95f854ef0cd1bba5f469175f67cd332f5c2561941f165e3dd65cee94d6d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6cf8cc5d07cf8003255f9d766fe8188b9f6e33b6240e126a605f0d061566b23e\",\"dweb:/ipfs/Qmd7okDCSoUt1L4G9hmb5c4W8kWUnfpAa2jyBKUp4xKErd\"]},\"lib/openzeppelin-contracts/contracts/token/ERC721/IERC721Receiver.sol\":{\"keccak256\":\"0xb5afb8e8eebc4d1c6404df2f5e1e6d2c3d24fd01e5dfc855314951ecfaae462d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://78586466c424f076c6a2a551d848cfbe3f7c49e723830807598484a1047b3b34\",\"dweb:/ipfs/Qmb717ovcFxm7qgNKEShiV6M9SPR3v1qnNpAGH84D6w29p\"]},\"lib/openzeppelin-contracts/contracts/token/ERC721/utils/ERC721Holder.sol\":{\"keccak256\":\"0xaad20f8713b5cd98114278482d5d91b9758f9727048527d582e8e88fd4901fd8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5396e8dbb000c2fada59b7d2093b9c7c870fd09413ab0fdaba45d882959c6244\",\"dweb:/ipfs/QmXQn5XckSiUsUBpMYuiFeqnojRX4rKa9jmgjCPeTuPmhh\"]},\"lib/openzeppelin-contracts/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0xddce8e17e3d3f9ed818b4f4c4478a8262aab8b11ed322f1bf5ed705bb4bd97fa\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8084aa71a4cc7d2980972412a88fe4f114869faea3fefa5436431644eb5c0287\",\"dweb:/ipfs/Qmbqfs5dRdPvHVKY8kTaeyc65NdqXRQwRK7h9s5UJEhD1p\"]},\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f6fda447a62815e8064f47eff0dd1cf58d9207ad69b5d32280f8d7ed1d1e4621\",\"dweb:/ipfs/QmfDRc7pxfaXB2Dh9np5Uf29Na3pQ7tafRS684wd3GLjVL\"]},\"src/AbstractEnsoShortcuts.sol\":{\"keccak256\":\"0x13d1f02f59cb1eaa7fa5867c490c3424ba140b060c9d3f1726ea886259f61eec\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://f4b0824a7235e4fe94c81ddfc0c87ecb9b2f65a347267dde1c3e01771ed217ae\",\"dweb:/ipfs/QmcZSJXGvnr7csVJySJbyMzRjHgDC6NGo3ozWWNdccJtVK\"]},\"src/EnsoShortcuts.sol\":{\"keccak256\":\"0x0eb8687d49d7d069ac3d88476913d6bc061756b6b0285165eeccf3ec6c4c538e\",\"license\":\"GPL-3.0-only\",\"urls\":[\"bzz-raw://4a255f8ac6a4b11b7b9951d85ae1a351cd2b99285ff7c4e1a1f640e2ce0b5644\",\"dweb:/ipfs/QmT3xkize31ZhrGvwuQTxd8jutVAoH898Woq5hfsZtwJMZ\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","methods":{"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"onERC721Received(address,address,uint256,bytes)":{"details":"See {IERC721Receiver-onERC721Received}. Always returns `IERC721Receiver.onERC721Received.selector`."}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"137:313:9:-:0;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;299:20;;137:313;;;;;;;;299:20;137:313;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;-1:-1:-1;137:313:9;;;;;-1:-1:-1;137:313:9","linkReferences":{}},"deployedBytecode":{"object":"6080604052600436101561001a575b3615610018575f80fd5b005b5f3560e01c806301ffc9a714610079578063150b7a021461007457806395352c9f1461006f578063bc197c811461006a578063c34c08e5146100655763f23a6e610361000e576104a1565b61045d565b6103c8565b6102a0565b610198565b346100cd5760203660031901126100cd5760043563ffffffff60e01b81168091036100cd57630271189760e51b81149081156100bc575b50151560805260206080f35b6301ffc9a760e01b149050816100b0565b5f80fd5b600435906001600160a01b03821682036100cd57565b602435906001600160a01b03821682036100cd57565b634e487b7160e01b5f52604160045260245ffd5b90601f801991011681019081106001600160401b0382111761013257604052565b6100fd565b6001600160401b03811161013257601f01601f191660200190565b81601f820112156100cd5780359061016982610137565b926101776040519485610111565b828452602083830101116100cd57815f926020809301838601378301015290565b346100cd5760803660031901126100cd576101b16100d1565b506101ba6100e7565b506064356001600160401b0381116100cd576101da903690600401610152565b50604051630a85bd0160e11b8152602090f35b9181601f840112156100cd578235916001600160401b0383116100cd576020808501948460051b0101116100cd57565b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b602081016020825282518091526040820191602060408360051b8301019401925f915b83831061027357505050505090565b9091929394602080610291600193603f19868203018752895161021d565b97019301930191939290610264565b60803660031901126100cd576024356004356044356001600160401b0381116100cd576102d19036906004016101ed565b90926064356001600160401b0381116100cd57610350947f049d8dd84b6a6cc45d5f68a74b23450bd3e54d84fd405d91b8b286c78d51d2499361032d61031e6103339436906004016101ed565b610326610561565b36916104f6565b916106fb565b60408051948552602085019290925292a160405191829182610241565b0390f35b6001600160401b0381116101325760051b60200190565b9080601f830112156100cd57813561038281610354565b926103906040519485610111565b81845260208085019260051b8201019283116100cd57602001905b8282106103b85750505090565b81358152602091820191016103ab565b346100cd5760a03660031901126100cd576103e16100d1565b506103ea6100e7565b506044356001600160401b0381116100cd5761040a90369060040161036b565b506064356001600160401b0381116100cd5761042a90369060040161036b565b506084356001600160401b0381116100cd5761044a903690600401610152565b5060405163bc197c8160e01b8152602090f35b346100cd575f3660031901126100cd576040517f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03168152602090f35b346100cd5760a03660031901126100cd576104ba6100d1565b506104c36100e7565b506084356001600160401b0381116100cd576104e3903690600401610152565b5060405163f23a6e6160e01b8152602090f35b92919061050281610354565b936105106040519586610111565b602085838152019160051b8101918383116100cd5781905b838210610536575050505050565b81356001600160401b0381116100cd576020916105568784938701610152565b815201910190610528565b7f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316330361059357565b6339218f3b60e01b5f5260045ffd5b634e487b7160e01b5f52603260045260245ffd5b91908110156105c65760051b0190565b6105a2565b80518210156105c65760209160051b010190565b156105e657565b60405162461bcd60e51b815260206004820152601660248201527556616c7565206d75737420626520333220627974657360501b6044820152606490fd5b602081519101519060208110610638575090565b5f199060200360031b1b1690565b634e487b7160e01b5f52601160045260245ffd5b5f1981019190821161066857565b610646565b601f1981019190821161066857565b3d156106a6573d9061068d82610137565b9161069b6040519384610111565b82523d5f602084013e565b606090565b604051906106ba604083610111565b60078252662ab735b737bbb760c91b6020830152565b9081526001600160a01b0390911660208201526060604082018190526106f89291019061021d565b90565b905f5b81811061070b5750505090565b6107168183856105b6565b359061074461073e61073861072b8560201b90565b6001600160f81b03191690565b60f81c90565b60ff1690565b9160408316159182610a02576001019261075f8486886105b6565b356020905b60038316600181036108bd57505f91829190602085166108a657610793916001600160e01b031987168c610a7b565b805190602001826001600160a01b0387165af1926107af61067c565b935b84901561080a575050608016156107e8576107e392916107d761072b6107dd9360581b90565b87610f7f565b60010190565b6106fe565b906107e392956107fe61072b6108049460581b90565b90610ed4565b936107dd565b8592506108156106ab565b946044815111610865575b505090610852915f1461085657925b60405163ef3dcb2f60e01b81529384936001600160a01b031690600485016106d0565b0390fd5b61085f9061065a565b9261082f565b602061087c600461087584610ca8565b9301610624565b036108205761088d60248301610624565b14610899575b80610820565b6044019350610852610893565b50607f6108b79160f81c168a6105cb565b51610793565b6002810361092057505f9182919060208516610909576108e8916001600160e01b031987168c610a7b565b8051906020016001600160a01b0386165afa9261090361067c565b936107b1565b50607f61091a9160f81c168a6105cb565b516108e8565b6003036109ca575f918161095161093e607f869560f81c168d6105cb565b5161094c60208251146105df565b610624565b91602086161584146109a35761097361096d6109859360081b90565b9161065a565b906001600160e01b031988168d610a7b565b905b815191602001906001600160a01b0387165af19261090361067c565b50607f6109bc61073e61073861072b6109c39560081b90565b168b6105cb565b5190610987565b60405162461bcd60e51b815260206004820152601060248201526f496e76616c69642063616c6c7479706560801b6044820152606490fd5b926006602883901b6001600160d01b0317610764565b6040516101609190610a2a8382610111565b600a815291601f1901366020840137565b906004820180921161066857565b90610a5382610137565b610a606040519182610111565b8281528092610a71601f1991610137565b0190602036910137565b91939290935f5f915f92610a8d610a18565b906060935f905b878210610be9575b5050610aaa610aaf91610a3b565b610a49565b9760208901525f9060248901925f955b878710610ad157505050505050505050565b60208710156105c657888b83891a6080811615610bc75760fe8103610b2c575050506020816001928752610b198d610b0883610a3b565b610b128b5161066d565b918b61112d565b875101601f1901955b0196019593610abf565b60fd819794959697145f14610b61575092610b5592868660019b948a9998978560209c52611283565b50979195909594610b22565b60fc8103610b83575092610b5592868660019b948a9998978560209c5261113f565b93610bc0888293610baf602096607f6001999c9b9a1690610ba482826105cb565b5151978895526105cb565b5190610bba85610a3b565b9161111b565b0195610b22565b60209250600193979150610bdf607f8492168d6105cb565b5101518152610b22565b9093959160208510156105c65786851a60ff8114610c94576080811615610c7f5760fe8103610c5f5750855115610c2f575b6020600191875101935b0196940190610a94565b945060016020604051610c5681610c488d858301610241565b03601f198101835282610111565b96915050610c1b565b90610c739260019692602095968a8d61104c565b95919390939294610c25565b610c8e6020916001938c610fd9565b93610c25565b509396509094929050610aaa610aaf610a9c565b9081516043198101818111610668579260445b828110610cc757505050565b81518110156105c657818101602001516001600160f81b03191615610cee57600101610cbb565b929350505060431981019081116106685790565b15610d0957565b60405162461bcd60e51b8152602060048201526013602482015272496e646578206f75742d6f662d626f756e647360681b6044820152606490fd5b15610d4b57565b60405162461bcd60e51b815260206004820152602860248201527f4f6e6c79206f6e652072657475726e2076616c7565207065726d697474656420604482015267287374617469632960c01b6064820152608490fd5b15610da857565b60405162461bcd60e51b815260206004820152602a60248201527f4f6e6c79206f6e652072657475726e2076616c7565207065726d697474656420604482015269287661726961626c652960b01b6064820152608490fd5b6020818303126100cd578051906001600160401b0382116100cd57019080601f830112156100cd57815191610e3483610354565b92610e426040519485610111565b80845260208085019160051b830101918383116100cd5760208101915b838310610e6e57505050505090565b82516001600160401b0381116100cd57820185603f820112156100cd57602081015191610e9a83610137565b610ea76040519182610111565b83815260408385010188106100cd575f602085819660408397018386015e83010152815201920191610e5f565b91908060f81c60ff8114610f79576080811615610f415760fe8103610f095750506106f8915060208082518301019101610e00565b602091610f1f610fe092607f8751911610610d02565b82840193610f2f84865114610da1565b51601f1901845260f31c168301015290565b610f75929150607f1690610f5784518310610d02565b610f646020825114610d44565b610f6e82856105cb565b52826105cb565b5090565b50505090565b9060f81c60ff8114610fd4578251906020820180921161066857602092607f610faa610fbd94610a49565b921691610fb783836105cb565b526105cb565b51918051604084018184840160045afa5051910152565b505050565b610fea90607f6020939416906105cb565b515103610ff75760200190565b60405162461bcd60e51b815260206004820152602760248201527f537461746963207374617465207661726961626c6573206d75737420626520336044820152663220627974657360c81b6064820152608490fd5b90969594939260fd810361106c5750956110669596611410565b90919293565b60fc81036110805750956110669596611329565b919650919493929161109591607f16906105cb565b515180151580611110575b156110ac570160200191565b60405162461bcd60e51b815260206004820152603660248201527f44796e616d6963207374617465207661726961626c6573206d7573742062652060448201527561206d756c7469706c65206f6620333220627974657360501b6064820152608490fd5b50601f8116156110a0565b916020809185930101920160045afa50565b910160200190829060400160045afa50565b9193959692905f9461115188846105cb565b51936024600180878b019b019b0198820101915b60208910611176575b505050505050565b80891a608081161561125a5760fb8103611190575061116e565b60fd819c92959a9499969b93979c145f146111e15750906111b892918b89528a858b89611283565b9260209a93926001928c969480919d939d97929d9e01970101985b019301979291939490611165565b60fc810361121b5750906111fc92918b89528a858b8961113f565b9260209a93926001928c969480919d939d97929d9e01970101986111d3565b6020898b8e6001959f9e97989661124e607f869716948d610baf61123f88886105cb565b515197889788978895526105cb565b019d01970101986111d3565b602060019293979694998161127788607f999e99839616906105cb565b5101518b5201986111d3565b9392919094956001019460208610156105c65760206112bd97816112ac607f868b1a16856105cb565b51015160248289010152019461113f565b929391929091602090910190565b156112d257565b60405162461bcd60e51b815260206004820152602960248201527f43616e6e6f74207573652073746174652066726f6d20696e736964652064796e604482015268616d6963207479706560b81b6064820152608490fd5b6001808501976020909601960194935f929091905b602087106113975760405162461bcd60e51b8152602060048201526024808201527f44796e616d6963207479706520776173206e6f742070726f7065726c7920636c6044820152631bdcd95960e21b6064820152608490fd5b80871a60808116156113f85760fb81036113bf575050506113b890836105cb565b5293929190565b6113df94956113d860fe839c949a969b959c14156112cb565b888b61104c565b9197909692939192916001906020905b0193019561133e565b61140a60209160019399969a85610fd9565b986113ef565b92919093946001019360208510156105c6576020611433607f83881a16866105cb565b515103611447576020611066960193611329565b60405162461bcd60e51b815260206004820152601d60248201527f4172726179206c656e677468206d7573742062652033322062797465730000006044820152606490fdfea2646970667358221220e2fb320215783417f0d03eadac743b8ea521353ce3d3b7d6166a03b67b81aff564736f6c634300081c0033","sourceMap":"137:313:9:-:0;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;-1:-1:-1;;137:313:9;;;;;;;;;;;;;;;;-1:-1:-1;;;775:49:3;;;:89;;;;137:313:9;;;;;;;;;775:89:3;-1:-1:-1;;;862:40:6;;-1:-1:-1;775:89:3;;;137:313:9;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;;;;137:313:9;;;;;;-1:-1:-1;;137:313:9;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;:::o;:::-;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;137:313:9;;;;;;;;-1:-1:-1;;137:313:9;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;137:313:9;;;;;;1073:38:8;137:313:9;;;1033:25:8;137:313:9;;;;;;:::i;:::-;960:23:8;;:::i;:::-;137:313:9;;;:::i;:::-;1033:25:8;;:::i;:::-;137:313:9;;;;;;;;;;;;;;1073:38:8;137:313:9;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;191:33;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;-1:-1:-1;;137:313:9;;;;;;:::i;:::-;;;;:::i;:::-;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;:::i;:::-;-1:-1:-1;137:313:9;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;:::i;:::-;;;;;;;;;332:116;410:8;-1:-1:-1;;;;;137:313:9;396:10;:22;392:49;;332:116::o;392:49::-;427:14;;;;;;;;137:313;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;180:4:0:-;137:313:9;;180:4:0;;;;;;;;;;;;:::o;:::-;;;;:::o;:::-;137:313:9;;-1:-1:-1;;;180:4:0;;;;;;;;;;;137:313:9;-1:-1:-1;;;137:313:9;;;180:4:0;;;;;137:313:9;;;;;180:4:0;;137:313:9;180:4:0;;;;;;:::o;:::-;;;;137:313:9;180:4:0;;;137:313:9;180:4:0;;:::o;465::1:-;137:313:9;;;465:4:1;;;;;;;;;-1:-1:-1;;465:4:1;;;;;;;;:::o;:::-;;:::i;:::-;-1:-1:-1;;465:4:1;;;;;;;;:::o;:::-;;;;;;;;;;:::i;:::-;137:313:9;;;;;;;:::i;:::-;465:4:1;;;-1:-1:-1;465:4:1;;;;:::o;:::-;137:313:9;465:4:1;:::o;:::-;137:313:9;;;;;;;:::i;:::-;465:4:1;;;-1:-1:-1;;;137:313:9;465:4:1;;;:::o;:::-;137:313:9;;;-1:-1:-1;;;;;137:313:9;;;465:4:1;;;137:313:9;465:4:1;;;;;;;;;;;;;:::i;:::-;;:::o;806:5657::-;;137:313:9;1163:18:1;;;;;;6444:12;;;806:5657;:::o;1183:26::-;1235:11;;;;;:::i;:::-;137:313:9;1289:13:1;1268:37;1276:28;1282:21;1289:13;;137:313:9;;;;1289:13:1;-1:-1:-1;;;;;;137:313:9;;;1282:21:1;137:313:9;;;;1276:28:1;137:313:9;;;;1268:37:1;1324:29;516:4;1324:29;;:34;;;;;137:313:9;;1432:11:1;;;;;;:::i;:::-;137:313:9;1300:2:1;1320:310;;426:4;1648:20;;289:4;1648:36;;289:4;;-1:-1:-1;137:313:9;;;;1826:399:1;1300:2;1826:17;;1300:2;;1875:180;;-1:-1:-1;;;;;;137:313:9;;1875:180:1;;:::i;:::-;1725:518;;;1300:2;1725:518;137:313:9;-1:-1:-1;;;;;137:313:9;;1725:518:1;;;;;:::i;:::-;1704:539;1644:2446;4109:7;4108:8;;4104:2093;;-1:-1:-1;;563:4:1;6215:25;:30;563:4;;7080:3;6289:13;;6282:21;6289:13;6305:7;6289:13;137:313:9;;;;6282:21:1;6305:7;;:::i;:::-;137:313:9;;;;7080:3:1;1152:9;;6211:214;6386:13;7080:3;6386:13;;6379:21;6386:13;6360:50;6386:13;137:313:9;;;;6379:21:1;6360:50;;:::i;:::-;6211:214;7080:3;:::i;4104:2093::-;465:4;;;;;:::i;:::-;137:313:9;4208:2:1;137:313:9;;4191:19:1;4187:1703;;4104:2093;5967:94;;;5914:268;5967:94;;;;;;;516:4;137:313:9;-1:-1:-1;;;5914:268:1;;137:313:9;;;-1:-1:-1;;;;;137:313:9;;5914:268:1;;;;:::i;:::-;;;;5967:94;6056:5;;;:::i;:::-;5967:94;;;4187:1703;1300:2;4715:16;4585:83;4412:33;;;:::i;:::-;4585:83;;4715:16;:::i;:::-;4758:13;4187:1703;4754:1118;5038:16;4898:92;;;5038:16;:::i;:::-;5522:23;5518:332;;4754:1118;;4187:1703;;5518:332;4208:2;5669:100;;-1:-1:-1;5914:268:1;5518:332;;1826:399;137:313:9;180:4:0;2082:143:1;137:313:9;;;2117:82:1;2082:143;;:::i;:::-;;1826:399;;1644:2446;337:4;2268:42;;337:4;;-1:-1:-1;137:313:9;;;;2487:435:1;1300:2;2487:17;;1300:2;;2540:196;;-1:-1:-1;;;;;;137:313:9;;2540:196:1;;:::i;:::-;2351:593;;;1300:2;2351:593;-1:-1:-1;;;;;137:313:9;;2351:593:1;;;;;:::i;:::-;2330:614;1644:2446;;2487:435;137:313:9;180:4:0;2767:155:1;137:313:9;;;2806:86:1;2767:155;;:::i;:::-;;2487:435;;2264:1826;426:4;2969:41;426:4;;137:313:9;;;3277:10:1;3047:119;180:4:0;137:313:9;;;;3074:74:1;3047:119;;:::i;:::-;;3184:49;1300:2;137:313:9;;3192:14:1;3184:49;:::i;:::-;3277:10;:::i;:::-;3482:510;1300:2;3482:17;;:22;1300:2;;;;3697:17;3635:12;3531:254;3635:12;137:313:9;;;;3635:12:1;3697:17;;:::i;:::-;137:313:9;-1:-1:-1;;;;;;137:313:9;;3531:254:1;;:::i;:::-;3482:510;;3327:683;;;1300:2;3327:683;;-1:-1:-1;;;;;137:313:9;;3327:683:1;;;;;:::i;3482:510::-;3860:12;180:4:0;3847:119:1;:27;3853:20;3860:12;3812:180;3860:12;137:313:9;;;;3847:119:1;;3812:180;;:::i;:::-;;3482:510;;;2965:1125;516:4;137:313:9;-1:-1:-1;;;4049:26:1;;384:4;4049:26;;;384:4;;;;;137:313:9;-1:-1:-1;;;137:313:9;;;384:4:1;;;5914:268;1320:310;620:66;1614:1;137:313:9;;;;-1:-1:-1;;;;;1536:43:1;1320:310;;137:313:9;;;;;;;;;;:::i;:::-;916:2:0;137:313:9;;;-1:-1:-1;;137:313:9;;;;;;:::o;268:4:0:-;;2314:1;268:4;;;;;;;:::o;:::-;;465::1;;;:::i;:::-;137:313:9;;;;;;:::i;:::-;465:4:1;;;268::0;137:313:9;268:4:0;137:313:9;;268:4:0;;:::i;:::-;;137:313:9;268:4:0;137:313:9;268:4:0;;137:313:9;268:4:0:o;414:4762::-;;;;;;137:313:9;;792:12:0;137:313:9;902:17:0;;;:::i;:::-;1032:22;137:313:9;1185:9:0;137:313:9;1180:1079:0;1196:17;;;;;;1180:1079;2306:9;;;2296:20;2306:9;;:::i;:::-;2296:20;:::i;:::-;2326:63;1243:10;2326:63;;;137:313:9;2471:54:0;;;;2539:9;137:313:9;2534:2636:0;2550:17;;;;;;414:4762;;;;;;;;;:::o;2539:9::-;1243:10;2597;;;;;;;;;;563:4:1;2626:25:0;;:30;563:4:1;;268::0;2680:20;;268:4;;2724:76;;;1243:10;2724:76;137:313:9;2724:76:0;;;2821:59;2848:8;;;;:::i;:::-;2858:21;137:313:9;;2858:21:0;:::i;:::-;2821:59;;;:::i;:::-;137:313:9;;268:4:0;-1:-1:-1;;268:4:0;;2676:2057;268:4;137:313:9;;2539:9:0;;;;2676:2057;313:4;3018:22;;;;;;;3014:1719;313:4;;;3138:76;;3260:265;3138:76;;;137:313:9;3138:76:0;;;;;;;1243:10;3138:76;;3260:265;:::i;:::-;3235:290;;;;;;3014:1719;2676:2057;;3014:1719;358:4;3554:22;;358:4;;3674:76;;3796:265;3674:76;;;137:313:9;3674:76:0;;;;;;;1243:10;3674:76;;3796:265;:::i;3550:1183::-;4175:20;4417:203;4175:20;;;4449:27;1243:10;4175:20;180:4;137:313:9;4175:20:0;;;;;4169:27;;;;;:::i;:::-;;137:313:9;4320:76:0;;;;4449:27;:::i;:::-;;4558:8;;;;:::i;:::-;4417:203;;:::i;:::-;268:4;3550:1183;2676:2057;;2622:2450;1243:10;4881:20;;137:313:9;4881:20:0;;;;4875:27;180:4;4881:20;;;4875:27;;:::i;:::-;;4970:88;;;;2622:2450;;1185:9;1243:10;;;;;;;;;;;;;225:4;1272:22;;1268:101;;563:4:1;1386:25:0;;:30;563:4:1;;268::0;1440:20;;268:4;;137:313:9;;;1488:21:0;1484:105;;1436:627;1243:10;137:313:9;;;;268:4:0;1436:627;;268:4;;1185:9;137:313:9;;1185:9:0;;1484:105;137:313:9;;;1243:10:0;137:313:9;;1549:17:0;;;;;;;;:::i;:::-;;137:313:9;;1549:17:0;;;;;;:::i;:::-;1484:105;;;;;;1436:627;1780:264;;;137:313:9;1780:264:0;;1243:10;1780:264;;;;;:::i;:::-;1740:304;;;;;;1436:627;;;1382:780;2109:38;1243:10;2109:38;137:313:9;2109:38:0;;;:::i;:::-;1382:780;;;1268:101;-1:-1:-1;1314:17:0;;-1:-1:-1;1314:17:0;;1349:5;1314:17;-1:-1:-1;2306:9:0;2296:20;1349:5;;6469:500:1;;137:313:9;;465:4:1;;;;;;;;;6696:15;4208:2;6713:10;;;;;;6469:500;;;:::o;6696:15::-;137:313:9;;;;;;;;;;;;;-1:-1:-1;;;;;;137:313:9;6745:12:1;6741:153;;137:313:9;;6696:15:1;;6741:153;6849:7;;;;;465:4;;;;;;;;;6874:5;6469:500::o;137:313:9:-;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;137:313:9;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;137:313:9;;-1:-1:-1;137:313:9;;;;;;;;;;;;;;;;;;;;;;;;15257:1683:0;;;137:313:9;;;;15455:22:0;;15451:40;;563:4:1;15506:25:0;;:30;563:4:1;;268::0;15556:20;;268:4;;137:313:9;;15604:29:0;137:313:9;;15604:29:0;137:313:9;;;15604:29:0;;;;;;:::i;15552:1041::-;15883:81;137:313:9;15672:67:0;16125:454;137:313:9;180:4:0;137:313:9;;15680:20:0;;:35;15672:67;:::i;:::-;15883:81;;;;15981:125;15883:81;;;16010:12;15981:125;:::i;:::-;16125:454;-1:-1:-1;;16125:454:0;;;;;;;;;;465:4:1;:::o;15502:1409:0:-;16864:36;16631:20;;;180:4;16631:20;137:313:9;16623:67:0;137:313:9;;16631:35:0;;16623:67;:::i;:::-;16731:118;16773:2;137:313:9;;16756:19:0;16731:118;:::i;:::-;16864:36;;;;:::i;:::-;;;;:::i;:::-;;15257:1683;:::o;15451:40::-;15479:12;;;;:::o;16946:454::-;;137:313:9;;;17117:22:0;;17113:35;;137:313:9;;268:4:0;17235:2;268:4;;;;;;;17235:2;17209:29;180:4;17209:29;17179:59;17209:29;;:::i;:::-;17185:20;;17179:59;;;;;:::i;:::-;;;:::i;:::-;;137:313:9;;;17575:292:0;;;;;;;;;;;17301:93;17575:292;;17301:93;16946:454::o;17113:35::-;17141:7;;;:::o;5182:358::-;5363:27;5182:358;180:4;5401:2;5182:358;;5369:20;5363:27;;:::i;:::-;;137:313:9;5363:40:0;137:313:9;;5401:2:0;268:4;5182:358;:::o;137:313:9:-;;;-1:-1:-1;;;137:313:9;;5401:2:0;137:313:9;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;6192:1182:0;;;;;;;313:4;6583:22;;313:4;;6677:184;;;;;;:::i;:::-;6621:240;;;6579:789;6192:1182::o;6579:789::-;358:4;6882:22;;358:4;;6976:184;;;;;;:::i;6878:490::-;7191:34;;-1:-1:-1;7191:34:0;;;;;5726:27;;180:4;5732:20;;5726:27;:::i;:::-;;137:313:9;5893:11:0;;;:31;;;6878:490;137:313:9;;;268:4:0;6167:2;268:4;;6192:1182::o;137:313:9:-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;5893:31:0;137:313:9;;;;5908:16:0;5893:31;;17406:467;;17575:292;17406:467;;;;17575:292;;;;;;;;17406:467::o;:::-;17575:292;;1243:10;17575:292;;17406:467;;17575:292;;;;;;17406:467::o;11339:3912::-;;;;;;;137:313:9;11785:25:0;;;;;:::i;:::-;137:313:9;268:4:0;12164:78;11981:1;268:4;;;;;;;;12164:78;;;;12251:2994;12258:13;12269:2;12258:13;;;;12251:2994;11339:3912;;;;;;:::o;12251:2994::-;12299:17;;;563:4:1;12335:25:0;;:30;563:4:1;;403::0;12389:22;;403:4;;12435:5;;;12385:2330;313:4;12469:22;;;;;;;;;;;;;12465:2250;313:4;;;12589:89;;12743:278;12589:89;;;;;12743:278;;;;;:::i;:::-;;12269:2;12743:278;;;11981:1;12743:278;;;;12699:322;;;;;;;;268:4;;;;;12465:2250;;268:4;137:313:9;;12251:2994:0;;;;;;;;12465:2250;358:4;13218:22;;358:4;;13338:89;;13492:278;13338:89;;;;;13492:278;;;;;:::i;:::-;;12269:2;13492:278;;;11981:1;13492:278;;;;13448:322;;;;;;;;268:4;;;;;13214:1501;12465:2250;;13214:1501;12269:2;14045:20;;;11981:1;14045:20;;;;;;14279:206;180:4;14045:20;;;14039:27;;14311;14039;;;;:::i;:::-;;137:313:9;14169:89:0;;;;;;;;14311:27;:::i;14279:206::-;268:4;;;;;;13214:1501;12465:2250;;12331:2803;12269:2;11981:1;14863:20;;;;;;;14857:27;14863:20;180:4;14863:20;;;;;;14857:27;;:::i;:::-;;14946:94;;;;268:4;12331:2803;;;10153:1180;;;;;;;10620:1;268:4;10732:17;10659:2;10732:17;;;;;10659:2;11035:179;10732:17;;10848:27;180:4;10732:17;;;10854:20;10848:27;;:::i;:::-;;10885:97;;;;;;;;268:4;11035:179;;:::i;:::-;;;;;;;10659:2;268:4;;;;10153:1180::o;137:313:9:-;;;;:::o;:::-;;;-1:-1:-1;;;137:313:9;;;;;;;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;;8333:1814:0;8912:1;268:4;;;;8988:2;268:4;;;;;;8333:1814;137:313:9;;8333:1814:0;;;9017:13;8988:2;9017:13;;;;137:313:9;;-1:-1:-1;;;10094:46:0;;137:313:9;10094:46:0;;;137:313:9;;;;;;;;;;;-1:-1:-1;;;137:313:9;;;;;;5914:268:1;9010:1075:0;9058:17;;;563:4:1;9094:25:0;;:30;563:4:1;;403::0;9148:22;;403:4;;9194:37;;;;;;;:::i;:::-;137:313:9;9316:60:0;;;;:::o;9144:730::-;9575:280;9431:20;;9423:74;268:4;9431:20;;;;;;;;;;9423:74;:::i;:::-;9575:280;;;:::i;:::-;;;;;;;;;;8912:1;;8988:2;;9090:889;268:4;137:313:9;;9010:1075:0;;;9090:889;9923:41;8988:2;9923:41;8912:1;9923:41;;;;;;:::i;:::-;9090:889;;;7380:947;;;;;;7872:1;268:4;7948:17;7906:2;7948:17;;;;;7906:2;7997:27;180:4;7948:17;;;8003:20;7997:27;;:::i;:::-;;137:313:9;7997:40:0;137:313:9;;7906:2:0;8158:162;268:4;;8158:162;;:::i;137:313:9:-;;;-1:-1:-1;;;137:313:9;;7906:2:0;137:313:9;;;;;;;;;;;;;;;;","linkReferences":{},"immutableReferences":{"1971":[{"start":1138,"length":32},{"start":1379,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"executeShortcut(bytes32,bytes32,bytes32[],bytes[])","signatureHash4":"0x95352c9f","signatureHash32":"0x95352c9f42748eb17da944d6c4210b51b640c9785eb0093259b6ab3f95407b9e"},{"signature":"executor()","signatureHash4":"0xc34c08e5","signatureHash32":"0xc34c08e5b349909cdfdda226c598387b4224f940b674ab2b0e4645c41e4cfcfa"},{"signature":"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)","signatureHash4":"0xbc197c81","signatureHash32":"0xbc197c819b3e337a6f9652dd10becd7eef83032af3b9d958d3d42f6694146621"},{"signature":"onERC1155Received(address,address,uint256,uint256,bytes)","signatureHash4":"0xf23a6e61","signatureHash32":"0xf23a6e612e1ff4830e658fe43f4e3cb4a5f8170bd5d9e69fb5d7a7fa9e4fdf97"},{"signature":"onERC721Received(address,address,uint256,bytes)","signatureHash4":"0x150b7a02","signatureHash32":"0x150b7a023d4804d13e8c85fb27262cb750cf6ba9f9dd3bb30d90f482ceeb4b1f"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"}],"event":[{"signature":"ShortcutExecuted(bytes32,bytes32)","signatureHash4":"0x049d8dd8","signatureHash32":"0x049d8dd84b6a6cc45d5f68a74b23450bd3e54d84fd405d91b8b286c78d51d249"}],"error":[{"signature":"ExecutionFailed(uint256,address,string)","signatureHash4":"0xef3dcb2f","signatureHash32":"0xef3dcb2fafaaa7e99b2e41035640888397f8f813cab3ceac180ca6a96570b6f5"},{"signature":"NotPermitted()","signatureHash4":"0x39218f3b","signatureHash32":"0x39218f3b3eae264e20259939b908bda5c449bd642a30892c5529ef94a57ff84e"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x4Fe93ebC4Ce6Ae4f81601cC7Ce7139023919E003"}