{"matchId":"56237080","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-10-16T17:09:12Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1057:12080:9:-:0;;;2606:397;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;822:1:8;803:20;;-1:-1:-1;;;;;2798:33:9;;;;;2841:22;;;;;2873:32;;;;2915:18;:36;;;;2961:12;:35;1057:12080;;14:177:10;93:13;;-1:-1:-1;;;;;135:31:10;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:600::-;302:6;310;318;326;334;387:3;375:9;366:7;362:23;358:33;355:53;;;404:1;401;394:12;355:53;427:40;457:9;427:40;:::i;:::-;417:50;;486:49;531:2;520:9;516:18;486:49;:::i;:::-;476:59;;554:49;599:2;588:9;584:18;554:49;:::i;:::-;665:2;650:18;;644:25;759:3;744:19;;;738:26;196:600;;;;-1:-1:-1;544:59:10;644:25;738:26;196:600;-1:-1:-1;;;196:600:10:o;:::-;1057:12080:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122025ad4b092468915da0e54201bd33b6f4e00c4355a5feaa2e8ac932a4d5beb82964736f6c634300081e0033","offset":4917}},"transformations":[{"type":"insert","offset":4970,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000483a1e7f16f46266400f1baf7abdf445c8d140a200000000000000000000000057fe1bfffcd7e2211d2b58a9e2a222f43b3ea31b000000000000000000000000d24400ae8bfebb18ca49be86258a3c749cf468530000000000000000000000000000000000000000000000000000001faa3b50000000000000000000000000000000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1057:12080:9:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12078:135;;;;;;:::i;:::-;;:::i;:::-;;7409:529;;;;;;:::i;:::-;;:::i;2396:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;345:25:10;;;333:2;318:18;2396:49:9;;;;;;;;9416:401;;;;;;:::i;:::-;;:::i;1433:34::-;;;;;;;;788:42:10;776:55;;;758:74;;746:2;731:18;1433:34:9;612:226:10;10225:413:9;;;;;;:::i;:::-;;:::i;1309:36::-;;;;;4294:333;;;;;;:::i;:::-;;:::i;1614:39::-;;;;;2519:61;;;;;;:::i;:::-;;;;;;;;;;;;;;2301:27;;;;;;11290:115;;;;;;:::i;:::-;;:::i;2005:33::-;;;;;;3790:498;;;;;;:::i;:::-;;:::i;8427:565::-;;;;;;:::i;:::-;;:::i;5567:272::-;;;;;;:::i;:::-;;:::i;722:31:8:-;;;;;;6249:299:9;;;;;;:::i;:::-;;:::i;12078:135::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;;;;;;;;;12165:41:::1;::::0;;;;::::1;::::0;::::1;345:25:10::0;;;12165:9:9::1;:32;;::::0;::::1;::::0;318:18:10;;12165:41:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12078:135:::0;:::o;7409:529::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;7488:15:::1;7506:36;7517:15;7534:7;7506:10;:36::i;:::-;7560:24;::::0;;;:15:::1;:24;::::0;;;;7553:31;7703:18:::1;::::0;7488:54;;-1:-1:-1;7703:28:9;;::::1;::::0;7749:32;::::1;7745:177;;7801:18;:31:::0;;;7856:51:::1;::::0;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;7856:51:9::1;::::0;2239:2:10;2224:18;7856:51:9::1;;;;;;;;7745:177;7595:337;7478:460;7409:529:::0;:::o;9416:401::-;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;9602:18:::1;::::0;:29;;::::1;::::0;9653:32;::::1;;9645:53;;;::::0;::::1;::::0;;2575:2:10;9645:53:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;9645:53:9::1;2373:331:10::0;9645:53:9::1;9713:18;:31:::0;;;9764:36:::1;::::0;;2883:25:10;;;2939:2;2924:18;;2917:34;;;9764:36:9::1;::::0;2856:18:10;9764:36:9::1;;;;;;;;9494:317;9416:401:::0;:::o;10225:413::-;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;10421:12:::1;::::0;:23;;::::1;::::0;10466:31;::::1;;10458:52;;;::::0;::::1;::::0;;2575:2:10;10458:52:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;10458:52:9::1;2373:331:10::0;10458:52:9::1;10525:12;:30:::0;;;10575:46:::1;::::0;;2883:25:10;;;2939:2;2924:18;;2917:34;;;10575:46:9::1;::::0;2856:18:10;10575:46:9::1;2709:248:10::0;4294:333:9;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;4403:12:::1;;4393:6;:22;;4385:49;;;::::0;::::1;::::0;;3164:2:10;4385:49:9::1;::::0;::::1;3146:21:10::0;3203:2;3183:18;;;3176:30;3242:16;3222:18;;;3215:44;3276:18;;4385:49:9::1;2962:338:10::0;4385:49:9::1;4549:12;::::0;;:21;;::::1;4534:36:::0;;4590:30:::1;::::0;;;;:14:::1;3497:55:10::0;;;4590:30:9::1;::::0;::::1;3479:74:10::0;3569:18;;;3562:34;;;4590:9:9::1;:14;::::0;::::1;::::0;3452:18:10;;4590:30:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4294:333:::0;;:::o;11290:115::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;11367:31:::1;::::0;;;;::::1;::::0;::::1;345:25:10::0;;;11367:9:9::1;:22;;::::0;::::1;::::0;318:18:10;;11367:31:9::1;199:177:10::0;3790:498:9;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;3885:19:::1;3907:9;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3885:45:::0;-1:-1:-1;4052:20:9;;::::1;4094:29:::0;;::::1;;4086:50;;;::::0;::::1;::::0;;2575:2:10;4086:50:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;4086:50:9::1;2373:331:10::0;4086:50:9::1;4177:18;;4159:14;:36;;4151:65;;;::::0;::::1;::::0;;3998:2:10;4151:65:9::1;::::0;::::1;3980:21:10::0;4037:2;4017:18;;;4010:30;4076:18;4056;;;4049:46;4112:18;;4151:65:9::1;3796:340:10::0;4151:65:9::1;4230:41;::::0;;;;:22:::1;3497:55:10::0;;;4230:41:9::1;::::0;::::1;3479:74:10::0;3569:18;;;3562:34;;;4230:9:9::1;:22;::::0;::::1;::::0;3452:18:10;;4230:41:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3941:341;3875:413;3790:498:::0;;:::o;8427:565::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;8511:15:::1;8529:48;8540:27;8569:7;8529:10;:48::i;:::-;8595:36;::::0;;;:27:::1;:36;::::0;;;;8588:43;8755:12:::1;::::0;8511:66;;-1:-1:-1;8755:22:9;;::::1;::::0;8795:31;::::1;8791:185;;8846:12;:30:::0;;;8900:61:::1;::::0;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;8900:61:9::1;::::0;2239:2:10;2224:18;8900:61:9::1;2049:319:10::0;5567:272:9;5632:14;;;5686:74;5699:15;5716:33;5751:8;5686:12;:74::i;:::-;5776:37;;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;5658:102:9;;-1:-1:-1;5658:102:9;-1:-1:-1;5776:37:9;;2239:2:10;2224:18;5776:37:9;;;;;;;;-1:-1:-1;5830:2:9;5567:272;-1:-1:-1;;5567:272:9:o;6249:299::-;6319:14;;;6373:91;6386:27;6415:38;6455:8;6373:12;:91::i;:::-;6480:42;;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;6345:119:9;;-1:-1:-1;6345:119:9;-1:-1:-1;6480:42:9;;2239:2:10;2224:18;6480:42:9;2049:319:10;6554:369:9;6651:15;6696:11;;;;;;;;;;6858:9;;;6885:12;;;6877:39;;;;;;;4343:2:10;6877:39:9;;;4325:21:10;4382:2;4362:18;;;4355:30;4421:16;4401:18;;;4394:44;4455:18;;6877:39:9;4141:338:10;6877:39:9;6668:255;6554:369;;;;:::o;4633:529::-;4746:14;4762:22;4804:8;4816:1;4804:13;4796:30;;;;;;;;;;;4686:2:10;4668:21;;;4725:1;4705:18;;;4698:29;4763:6;4758:2;4743:18;;4736:34;4802:2;4787:18;;4484:327;4796:30:9;4838:17;4857:11;4872:19;1435:17:8;1715:18;;;;;;;1786:154;;;1834:12;:16;;1824:27;1786:154;;;5389:19:10;5459:66;1881:4:8;5446:2:10;5442:15;5438:88;5424:12;;;5417:110;;;;5543:12;;;5536:28;;;5580:12;;1786:154:8;;;;;;;;;;;;1759:195;;;;;;1747:207;;1388:583;;;4872:19:9;4933:110;;;;;;4999:19:10;;;5060:66;5048:79;;5034:12;;;5027:101;;;;5144:12;;;5137:28;;;4837:54:9;;-1:-1:-1;4837:54:9;-1:-1:-1;5181:12:10;;4933:110:9;;;;;;;;;;;;;4910:143;;4933:110;4910:143;;;;5107:48;;;;;;;;-1:-1:-1;5094:10:9;;;;;;;;;:61;;;;;-1:-1:-1;4910:143:9;;4633:529;-1:-1:-1;;;4633:529:9:o;14:180:10:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:10;;14:180;-1:-1:-1;14:180:10:o;1092:429::-;1160:6;1168;1221:2;1209:9;1200:7;1196:23;1192:32;1189:52;;;1237:1;1234;1227:12;1189:52;1276:9;1263:23;1326:42;1319:5;1315:54;1308:5;1305:65;1295:93;;1384:1;1381;1374:12;1295:93;1407:5;1485:2;1470:18;;;;1457:32;;-1:-1:-1;;;1092:429:10:o;3607:184::-;3677:6;3730:2;3718:9;3709:7;3705:23;3701:32;3698:52;;;3746:1;3743;3736:12;3698:52;-1:-1:-1;3769:16:10;;3607:184;-1:-1:-1;3607:184:10:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa264697066735822122025ad4b092468915da0e54201bd33b6f4e00c4355a5feaa2e8ac932a4d5beb82964736f6c634300081e0033","offset":4587}},"immutableReferences":{"1852":[{"start":516,"length":32},{"start":971,"length":32},{"start":2381,"length":32},{"start":2678,"length":32},{"start":2908,"length":32},{"start":3342,"length":32}],"1855":[{"start":421,"length":32},{"start":784,"length":32},{"start":1107,"length":32},{"start":2496,"length":32},{"start":3459,"length":32}],"1858":[{"start":574,"length":32},{"start":1385,"length":32},{"start":1723,"length":32},{"start":2053,"length":32},{"start":2770,"length":32}]},"transformations":[{"id":"1855","type":"replace","offset":421,"reason":"immutable"},{"id":"1852","type":"replace","offset":516,"reason":"immutable"},{"id":"1858","type":"replace","offset":574,"reason":"immutable"},{"id":"1855","type":"replace","offset":784,"reason":"immutable"},{"id":"1852","type":"replace","offset":971,"reason":"immutable"},{"id":"1855","type":"replace","offset":1107,"reason":"immutable"},{"id":"1858","type":"replace","offset":1385,"reason":"immutable"},{"id":"1858","type":"replace","offset":1723,"reason":"immutable"},{"id":"1858","type":"replace","offset":2053,"reason":"immutable"},{"id":"1852","type":"replace","offset":2381,"reason":"immutable"},{"id":"1855","type":"replace","offset":2496,"reason":"immutable"},{"id":"1852","type":"replace","offset":2678,"reason":"immutable"},{"id":"1858","type":"replace","offset":2770,"reason":"immutable"},{"id":"1852","type":"replace","offset":2908,"reason":"immutable"},{"id":"1852","type":"replace","offset":3342,"reason":"immutable"},{"id":"1855","type":"replace","offset":3459,"reason":"immutable"}],"transformationValues":{"immutables":{"1852":"0x000000000000000000000000483a1e7f16f46266400f1baf7abdf445c8d140a2","1855":"0x00000000000000000000000057fe1bfffcd7e2211d2b58a9e2a222f43b3ea31b","1858":"0x000000000000000000000000d24400ae8bfebb18ca49be86258a3c749cf46853"}}},"deployment":{"transactionHash":"0x6396261879bcdf05c8755a482c07576e61fb50bf3a1f2cd42bd1c3decb9c7b17","blockNumber":"26155982","transactionIndex":"264","deployer":"0x40a59770B78823a467264A905278AE1F894C383D"},"sources":{"contracts/PrintLimiter.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20Impl.sol\";\nimport \"./LockRequestableV1dot1.sol\";\n\n/** @title  A contact to govern hybrid control over increases to the token supply.\n  *\n  * @notice  A contract that acts as a custodian of the active token\n  * implementation, and an intermediary between it and the ‘true’ custodian.\n  * It preserves the functionality of direct custodianship as well as granting\n  * limited control of token supply increases to an additional key.\n  *\n  * @dev  This contract is a layer of indirection between an instance of\n  * ERC20Impl and a custodian. The functionality of the custodianship over\n  * the token implementation is preserved (printing and custodian changes),\n  * but this contract adds the ability for an additional key\n  * (the 'limited printer') to increase the token supply up to a ceiling,\n  * and this supply ceiling can only be raised by the custodian.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract PrintLimiter is LockRequestableV1dot1 {\n\n    // TYPES\n    /// @dev The struct type for ceiling/limit raises.\n    struct Raise {\n        uint256 raiseBy;\n    }\n\n    // MEMBERS\n    /// @dev  The reference to the active token implementation.\n    ERC20Impl immutable public erc20Impl;\n\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address immutable public custodian;\n\n    /** @dev  The sole authorized caller of limited printing.\n      * This account is also authorized to lower the supply ceiling.\n      */\n    address immutable public limitedPrinter;\n\n    /** @dev  The maximum that the token supply can be increased to\n      * through use of the limited printing feature.\n      * The difference between the current total supply and the supply\n      * ceiling is what is available to the 'limited printer' account.\n      * The value of the ceiling can only be increased by the custodian.\n      */\n    uint256 public totalSupplyCeiling;\n\n    /** @dev  The maximum that can be seized (burnt) through use of\n      * the limited burn feature.\n      * The value of the limit can only be increased by the custodian.\n      * The value of the limit can be decreased by the 'limited printer'.\n      */\n    uint256 public seizureLimit;\n\n    /// @dev  The map of lock ids to pending ceiling raises.\n    mapping (bytes32 => Raise) public pendingRaiseMap;\n\n    /// @dev  The map of lock ids to pending seizure limit raises.\n    mapping (bytes32 => Raise) public pendingSeizureLimitRaiseMap;\n\n    // CONSTRUCTOR\n    constructor(\n        address _erc20Impl,\n        address _custodian,\n        address _limitedPrinter,\n        uint256 _initialCeiling,\n        uint256 _initialSeizureLimit\n    )\n    {\n        erc20Impl = ERC20Impl(_erc20Impl);\n        custodian = _custodian;\n        limitedPrinter = _limitedPrinter;\n        totalSupplyCeiling = _initialCeiling;\n        seizureLimit = _initialSeizureLimit;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian, \"unauthorized\");\n        _;\n    }\n    modifier onlyLimitedPrinter {\n        require(msg.sender == limitedPrinter, \"unauthorized\");\n        _;\n    }\n\n    /** @notice  Increases the token supply, with the newly created tokens\n      * being added to the balance of the specified account.\n      *\n      * @dev  The function checks that the value to print does not\n      * exceed the supply ceiling when added to the current total supply.\n      * NOTE: printing to the zero address is disallowed.\n      *\n      * @param  _receiver  The receiving address of the print.\n      * @param  _value  The number of tokens to add to the total supply and the\n      * balance of the receiving address.\n      */\n    function limitedPrint(address _receiver, uint256 _value) external onlyLimitedPrinter {\n        uint256 totalSupply = erc20Impl.totalSupply();\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follow\n            uint256 newTotalSupply = totalSupply + _value;\n            require(newTotalSupply >= totalSupply, \"overflow\");\n\n            require(newTotalSupply <= totalSupplyCeiling, \"ceiling exceeded\");\n            erc20Impl.executePrint(_receiver, _value);\n        }\n    }\n\n    function limitedBurn(address _owner, uint256 _value) external onlyLimitedPrinter {\n        require(_value <= seizureLimit, \"limit exceeded\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= seizureLimit`\n            seizureLimit = seizureLimit - _value;\n        }\n        erc20Impl.burn(_owner, _value);\n    }\n\n    function requestRaise(mapping(bytes32 => Raise) storage _m, bytes4 _selector, uint256 _raiseBy) private returns (bytes32 lockId, uint256 lockRequestIdx) {\n        require(_raiseBy != 0, \"zero\");\n\n        (bytes32 preLockId, uint256 idx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                _selector,\n                _raiseBy\n            )\n        );\n        lockRequestIdx = idx;\n\n        _m[lockId] = Raise({\n            raiseBy: _raiseBy\n        });\n    }\n\n    /** @notice  Requests an increase to the supply ceiling.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _raiseBy  The amount by which to raise the ceiling.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCeilingRaise(uint256 _raiseBy) external returns (bytes32 lockId) {\n        (bytes32 id, uint256 idx) = requestRaise(pendingRaiseMap, this.requestCeilingRaise.selector, _raiseBy);\n\n        emit CeilingRaiseLocked(id, _raiseBy, idx);\n        return id;\n    }\n\n    /** @notice  Requests an increase to the seizure limit.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _raiseBy  The amount by which to raise the seizure limit.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestSeizureLimitRaise(uint256 _raiseBy) external returns (bytes32 lockId) {\n        (bytes32 id, uint256 idx) = requestRaise(pendingSeizureLimitRaiseMap, this.requestSeizureLimitRaise.selector, _raiseBy);\n\n        emit SeizureLimitRaiseLocked(id, _raiseBy, idx);\n        return id;\n    }\n\n    function getRequest(mapping(bytes32 => Raise) storage _m, bytes32 _lockId) private view returns (uint256 raiseBy) {\n        Raise storage r = _m[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        raiseBy = r.raiseBy;\n        require(raiseBy != 0, \"no such lockId\");\n    }\n\n    /** @notice  Confirms a pending increase in the token supply.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending ceiling increase, the amount requested is added to the\n      * current supply ceiling.\n      * NOTE: this function will not execute any raise that would overflow the\n      * supply ceiling, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending ceiling raise request.\n      */\n    function confirmCeilingRaise(bytes32 _lockId) external onlyCustodian {\n        uint256 raiseBy = getRequest(pendingRaiseMap, _lockId);\n\n        delete pendingRaiseMap[_lockId];\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newCeiling = totalSupplyCeiling + raiseBy;\n            if (newCeiling >= totalSupplyCeiling) {\n                totalSupplyCeiling = newCeiling;\n\n                emit CeilingRaiseConfirmed(_lockId, raiseBy, newCeiling);\n            }\n        }\n    }\n\n    /** @notice  Confirms a pending increase in the seizure limit.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending seizure limit increase, the amount requested is added to the\n      * current limit.\n      * NOTE: this function will not execute any raise that would overflow the\n      * seizure limit, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending seizure limit raise request.\n      */\n    function confirmSeizureLimitRaise(bytes32 _lockId) external onlyCustodian {\n        uint256 raiseBy = getRequest(pendingSeizureLimitRaiseMap, _lockId);\n\n        delete pendingSeizureLimitRaiseMap[_lockId];\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newSeizureLimit = seizureLimit + raiseBy;\n            if (newSeizureLimit >= seizureLimit) {\n                seizureLimit = newSeizureLimit;\n\n                emit SeizureLimitRaiseConfirmed(_lockId, raiseBy, newSeizureLimit);\n            }\n        }\n    }\n\n    /** @notice  Lowers the supply ceiling, further constraining the bound of\n      * what can be printed by the limited printer.\n      *\n      * @dev  The limited printer is the sole authorized caller of this function,\n      * so it is the only account that can elect to lower its limit to increase\n      * the token supply.\n      *\n      * @param  _lowerBy  The amount by which to lower the supply ceiling.\n      */\n    function lowerCeiling(uint256 _lowerBy) external onlyLimitedPrinter {\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newCeiling = totalSupplyCeiling - _lowerBy;\n            require(newCeiling <= totalSupplyCeiling, \"overflow\");\n\n            totalSupplyCeiling = newCeiling;\n\n            emit CeilingLowered(_lowerBy, newCeiling);\n        }\n    }\n\n    /** @notice  Lowers the seizure limit, further constraining the bound of\n      * what can be seized (burnt) by the limited printer.\n      *\n      * @dev  The limited printer is the sole authorized caller of this function,\n      * so it is the only account that can elect to lower its limit to seize assets.\n      *\n      * @param  _lowerBy  The amount by which to lower the seizure limit.\n      */\n    function lowerSeizureLimit(uint256 _lowerBy) external onlyLimitedPrinter {\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newSeizureLimit = seizureLimit - _lowerBy;\n            require(newSeizureLimit <= seizureLimit, \"overflow\");\n\n            seizureLimit = newSeizureLimit;\n\n            emit SeizureLimitLowered(_lowerBy, newSeizureLimit);\n        }\n    }\n\n    /** @notice  Pass-through control of print confirmation, allowing this\n      * contract's custodian to act as the custodian of the associated\n      * active token implementation.\n      *\n      * @dev  This contract is the direct custodian of the active token\n      * implementation, but this function allows this contract's custodian\n      * to act as though it were the direct custodian of the active\n      * token implementation. Therefore the custodian retains control of\n      * unlimited printing.\n      *\n      * @param  _lockId  The identifier of a pending print request in\n      * the associated active token implementation.\n      */\n    function confirmPrintProxy(bytes32 _lockId) external onlyCustodian {\n        erc20Impl.confirmPrint(_lockId);\n    }\n\n    /** @notice  Pass-through control of custodian change confirmation,\n      * allowing this contract's custodian to act as the custodian of\n      * the associated active token implementation.\n      *\n      * @dev  This contract is the direct custodian of the active token\n      * implementation, but this function allows this contract's custodian\n      * to act as though it were the direct custodian of the active\n      * token implementation. Therefore the custodian retains control of\n      * custodian changes.\n      *\n      * @param  _lockId  The identifier of a pending custodian change request\n      * in the associated active token implementation.\n      */\n    function confirmCustodianChangeProxy(bytes32 _lockId) external onlyCustodian {\n        erc20Impl.confirmCustodianChange(_lockId);\n    }\n\n    // EVENTS\n    /// @dev  Emitted by successful `requestCeilingRaise` calls.\n    event CeilingRaiseLocked(bytes32 _lockId, uint256 _raiseBy, uint256 _lockRequestIdx);\n    /// @dev  Emitted by successful `confirmCeilingRaise` calls.\n    event CeilingRaiseConfirmed(bytes32 _lockId, uint256 _raiseBy, uint256 _newCeiling);\n\n    /// @dev  Emitted by successful `requestSeizureLimitRaise` calls.\n    event SeizureLimitRaiseLocked(bytes32 _lockId, uint256 _raiseBy, uint256 _lockRequestIdx);\n    /// @dev  Emitted by successful `confirmSeizureLimitRaise` calls.\n    event SeizureLimitRaiseConfirmed(bytes32 _lockId, uint256 _raiseBy, uint256 _newSeizureLimit);\n\n    /// @dev  Emitted by successful `lowerCeiling` calls.\n    event CeilingLowered(uint256 _lowerBy, uint256 _newCeiling);\n\n    /// @dev  Emitted by successful `lowerSeizureLimit` calls.\n    event SeizureLimitLowered(uint256 _lowerBy, uint256 _newSeizureLimit);\n}\n"},"contracts/ERC20Impl.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./CustodianUpgradeableV1dot1.sol\";\nimport \"./ERC20Proxy.sol\";\nimport \"./ERC20Store.sol\";\n\n/** @title  ERC20 compliant token intermediary contract holding core logic.\n  *\n  * @notice  This contract serves as an intermediary between the exposed ERC20\n  * interface in ERC20Proxy and the store of balances in ERC20Store. This\n  * contract contains core logic that the proxy can delegate to\n  * and that the store is called by.\n  *\n  * @dev  This contract contains the core logic to implement the\n  * ERC20 specification as well as several extensions.\n  * 1. Changes to the token supply.\n  * 2. Batched transfers.\n  * 3. Relative changes to spending approvals.\n  * 4. Delegated transfer control ('sweeping').\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Impl is CustodianUpgradeableV1dot1 {\n\n    // TYPES\n    /// @dev  The struct type for pending increases to the token supply (print).\n    struct PendingPrint {\n        address receiver;\n        uint256 value;\n    }\n\n    // MEMBERS\n    /// @dev  The reference to the proxy.\n    ERC20Proxy immutable public erc20Proxy;\n\n    /// @dev  The reference to the store.\n    ERC20Store immutable public erc20Store;\n\n    /// @dev  The map of lock ids to pending token increases.\n    mapping (bytes32 => PendingPrint) public pendingPrintMap;\n\n    // CONSTRUCTOR\n    constructor(\n          address _erc20Proxy,\n          address _erc20Store,\n          address _custodian\n    )\n        CustodianUpgradeableV1dot1(_custodian)\n    {\n        erc20Proxy = ERC20Proxy(_erc20Proxy);\n        erc20Store = ERC20Store(_erc20Store);\n    }\n\n    // MODIFIERS\n    modifier onlyProxy {\n        require(msg.sender == address(erc20Proxy), \"unauthorized\");\n        _;\n    }\n\n\n    /** @notice  Core logic of the ERC20 `approve` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has an `approve` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval in proxy.\n      */\n    function approveWithSender(\n        address _sender,\n        address _spender,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        erc20Store.setAllowance(_sender, _spender, _value);\n        erc20Proxy.emitApproval(_sender, _spender, _value);\n        return true;\n    }\n\n    /** @notice  Core logic of the `increaseApproval` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has an `increaseApproval` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval.\n      */\n    function increaseApprovalWithSender(\n        address _sender,\n        address _spender,\n        uint256 _addedValue\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        uint256 currentAllowance = erc20Store.allowed(_sender, _spender);\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newAllowance = currentAllowance + _addedValue;\n            require(newAllowance >= currentAllowance, \"overflow\");\n\n            erc20Store.setAllowance(_sender, _spender, newAllowance);\n            erc20Proxy.emitApproval(_sender, _spender, newAllowance);\n            return true;\n        }\n    }\n\n    /** @notice  Core logic of the `decreaseApproval` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `decreaseApproval` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval.\n      */\n    function decreaseApprovalWithSender(\n        address _sender,\n        address _spender,\n        uint256 _subtractedValue\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        uint256 currentAllowance = erc20Store.allowed(_sender, _spender);\n\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newAllowance = currentAllowance - _subtractedValue;\n            require(newAllowance <= currentAllowance, \"overflow\");\n\n            erc20Store.setAllowance(_sender, _spender, newAllowance);\n            erc20Proxy.emitApproval(_sender, _spender, newAllowance);\n        }\n\n        return true;\n    }\n\n    /** @notice  Requests an increase in the token supply, with the newly created\n      * tokens to be added to the balance of the specified account.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      * NOTE: printing to the zero address is disallowed.\n      *\n      * @param  _receiver  The receiving address of the print, if confirmed.\n      * @param  _value  The number of tokens to add to the total supply and the\n      * balance of the receiving address, if confirmed.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestPrint(address _receiver, uint256 _value) external returns (bytes32 lockId) {\n        require(_receiver != address(0), \"zero address\");\n\n        (bytes32 preLockId, uint256 lockRequestIdx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                this.requestPrint.selector,\n                _receiver,\n                _value\n            )\n        );\n\n        pendingPrintMap[lockId] = PendingPrint({\n            receiver: _receiver,\n            value: _value\n        });\n\n        emit PrintingLocked(lockId, _receiver, _value, lockRequestIdx);\n    }\n\n    function _executePrint(address _receiver, uint256 _value) private returns (bool success) {\n        uint256 supply = erc20Store.totalSupply();\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newSupply = supply + _value;\n            if (newSupply >= supply) {\n                erc20Store.setTotalSupply(newSupply);\n                erc20Store.addBalance(_receiver, _value);\n\n                erc20Proxy.emitTransfer(address(0), _receiver, _value);\n                return true;\n            }\n        }\n    }\n\n    function executePrint(address _receiver, uint256 _value) external onlyCustodian {\n        require(_receiver != address(0), \"zero address\");\n        _executePrint(_receiver, _value);\n    }\n\n    /** @notice  Confirms a pending increase in the token supply.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending increase, the amount requested to be printed in the print request\n      * is printed to the receiving address specified in that same request.\n      * NOTE: this function will not execute any print that would overflow the\n      * total supply, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending print request.\n      */\n    function confirmPrint(bytes32 _lockId) external onlyCustodian {\n        PendingPrint storage print = pendingPrintMap[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        address receiver = print.receiver;\n        require (receiver != address(0), \"no such lockId\");\n        uint256 value = print.value;\n\n        delete pendingPrintMap[_lockId];\n\n        if (_executePrint(receiver, value)) {\n            emit PrintingConfirmed(_lockId, receiver, value);\n        }\n    }\n\n    function _executeBurn(address _owner, uint256 _value) private returns (bool success) {\n        uint256 balanceOfSender = erc20Store.balances(_owner);\n        require(_value <= balanceOfSender, \"insufficient balance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfSender`\n            erc20Store.setBalance(_owner, balanceOfSender - _value);\n            // unchecked `-` is safe as the global invariants is that\n            // the sum of all balances equals the total supply, therefore\n            // as `_value <= balanceOfSender`, then `_value <= totalSupply`\n            erc20Store.setTotalSupply(erc20Store.totalSupply() - _value);\n        }\n\n        erc20Proxy.emitTransfer(_owner, address(0), _value);\n\n        return true;\n    }\n\n    /** @notice  Burns the specified value from the sender's balance.\n      *\n      * @dev  Sender's balanced is subtracted by the amount they wish to burn.\n      *\n      * @param  _value  The amount to burn.\n      *\n      * @return  success  true if the burn succeeded.\n      */\n    function burn(uint256 _value) external returns (bool success) {\n        return _executeBurn(msg.sender, _value);\n    }\n\n    /** @notice  Burns the specified value from the owner's balance.\n      *\n      * @dev  Owner's balance is subtracted by the amount the custodian wishes to burn.\n      *\n      * @param  _owner  The owner of the tokens.\n      * @param  _value  The amount to burn.\n      */\n    function burn(address _owner, uint256 _value) external onlyCustodian {\n        _executeBurn(_owner, _value);\n    }\n\n    /** @notice  A function for a sender to issue multiple transfers to multiple\n      * different addresses at once. This function is implemented for gas\n      * considerations when someone wishes to transfer, as one transaction is\n      * cheaper than issuing several distinct individual `transfer` transactions.\n      *\n      * @dev  By specifying a set of destination addresses and values, the\n      * sender can issue one transaction to transfer multiple amounts to\n      * distinct addresses, rather than issuing each as a separate\n      * transaction. The `_tos` and `_values` arrays must be equal length, and\n      * an index in one array corresponds to the same index in the other array\n      * (e.g. `_tos[0]` will receive `_values[0]`, `_tos[1]` will receive\n      * `_values[1]`, and so on.)\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _tos  The destination addresses to receive the transfers.\n      * @param  _values  The values for each destination address.\n      * @return  success  If transfers succeeded.\n      */\n    function batchTransfer(address[] calldata _tos, uint256[] calldata _values) external returns (bool success) {\n        require(_tos.length == _values.length, \"inconsistent length\");\n\n        uint256 numTransfers = _tos.length;\n        uint256 senderBalance = erc20Store.balances(msg.sender);\n\n        for (uint256 i = 0; i < numTransfers; i++) {\n          address to = _tos[i];\n          require(to != address(0), \"zero address\");\n          uint256 v = _values[i];\n          require(senderBalance >= v, \"insufficient balance\");\n\n          if (msg.sender != to) {\n            senderBalance -= v;\n            erc20Store.addBalance(to, v);\n          }\n          erc20Proxy.emitTransfer(msg.sender, to, v);\n        }\n\n        erc20Store.setBalance(msg.sender, senderBalance);\n\n        return true;\n    }\n\n    /** @notice  Core logic of the ERC20 `transferFrom` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `transferFrom` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _sender  The address initiating the transfer in proxy.\n      */\n    function transferFromWithSender(\n        address _sender,\n        address _from,\n        address _to,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_to != address(0), \"zero address\"); // ensure burn is the cannonical transfer to 0x0\n\n        uint256 balanceOfFrom = erc20Store.balances(_from);\n        require(_value <= balanceOfFrom, \"insufficient balance\");\n\n        uint256 senderAllowance = erc20Store.allowed(_from, _sender);\n        require(_value <= senderAllowance, \"insufficient allowance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfFrom`\n            erc20Store.setBalance(_from, balanceOfFrom - _value);\n        }\n        erc20Store.addBalance(_to, _value);\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= senderAllowance`\n            erc20Store.setAllowance(_from, _sender, senderAllowance - _value);\n        }\n\n        erc20Proxy.emitTransfer(_from, _to, _value);\n\n        return true;\n    }\n\n    /** @notice  Core logic of the ERC20 `transfer` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `transfer` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _sender  The address initiating the transfer in proxy.\n      */\n    function transferWithSender(\n        address _sender,\n        address _to,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_to != address(0), \"zero address\"); // ensure burn is the cannonical transfer to 0x0\n\n        uint256 balanceOfSender = erc20Store.balances(_sender);\n        require(_value <= balanceOfSender, \"insufficient balance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfSender`\n            erc20Store.setBalance(_sender, balanceOfSender - _value);\n        }\n        erc20Store.addBalance(_to, _value);\n\n        erc20Proxy.emitTransfer(_sender, _to, _value);\n\n        return true;\n    }\n\n    // METHODS (ERC20 sub interface impl.)\n    /// @notice  Core logic of the ERC20 `totalSupply` function.\n    function totalSupply() external view returns (uint256) {\n        return erc20Store.totalSupply();\n    }\n\n    /// @notice  Core logic of the ERC20 `balanceOf` function.\n    function balanceOf(address _owner) external view returns (uint256 balance) {\n        return erc20Store.balances(_owner);\n    }\n\n    /// @notice  Core logic of the ERC20 `allowance` function.\n    function allowance(address _owner, address _spender) external view returns (uint256 remaining) {\n        return erc20Store.allowed(_owner, _spender);\n    }\n\n    // EVENTS\n    /// @dev  Emitted by successful `requestPrint` calls.\n    event PrintingLocked(bytes32 _lockId, address _receiver, uint256 _value, uint256 _lockRequestIdx);\n    /// @dev Emitted by successful `confirmPrint` calls.\n    event PrintingConfirmed(bytes32 _lockId, address _receiver, uint256 _value);\n}\n"},"contracts/LockRequestableV1dot1.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\n/** @title  A contract for generating unique identifiers\n  *\n  * @notice  A contract that provides a identifier generation scheme,\n  * guaranteeing uniqueness across all contracts that inherit from it,\n  * as well as unpredictability of future identifiers.\n  *\n  * @dev  This contract is intended to be inherited by any contract that\n  * implements the callback software pattern for cooperative custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract LockRequestableV1dot1 {\n\n    // MEMBERS\n    /// @notice  the count of all invocations of `generatePreLockId`.\n    uint256 public lockRequestCount;\n\n    // CONSTRUCTOR\n    constructor() {\n        lockRequestCount = 0;\n    }\n\n    // FUNCTIONS\n    /** @notice  Returns a fresh unique identifier.\n      *\n      * @dev the generation scheme uses three components.\n      * First, the blockhash of the previous block.\n      * Second, the deployed address.\n      * Third, the next value of the counter.\n      * This ensure that identifiers are unique across all contracts\n      * following this scheme, and that future identifiers are\n      * unpredictable.\n      *\n      * @return preLockId a 32-byte unique identifier.\n      * @return lockRequestIdx index of lock request\n\n      */\n    function generatePreLockId() internal returns (bytes32 preLockId, uint256 lockRequestIdx) {\n        unchecked {\n            // unchecked `-` is safe as this can never be evaluated in the genesis (0) block\n            // unchecked `++` is safe as it is infeasible to exhaust 256-bit integer counter\n            lockRequestIdx = ++lockRequestCount;\n            preLockId = keccak256(\n                abi.encodePacked(\n                    blockhash(block.number - 1),\n                    address(this),\n                    lockRequestIdx\n                )\n            );\n        }\n    }\n}\n"},"contracts/CustodianUpgradeableV1dot1.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./LockRequestableV1dot1.sol\";\n\n/** @title  A contract to inherit upgradeable custodianship.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * custodianship. That custodian may be an account or another contract.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a custodian to control some aspect of its functionality.\n  * This contract provides the mechanism for that custodianship to be\n  * passed from one custodian to the next.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract CustodianUpgradeableV1dot1 is LockRequestableV1dot1 {\n\n    // TYPES\n    /// @dev  The struct type for pending custodian changes.\n    struct CustodianChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address public custodian;\n\n    /// @dev  The map of lock ids to pending custodian changes.\n    mapping (bytes32 => CustodianChangeRequest) public custodianChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(\n        address _custodian\n    )\n      LockRequestableV1dot1()\n    {\n        custodian = _custodian;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian, \"unauthorized\");\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n\n    /** @notice  Requests a change of the custodian associated with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedCustodian  The address of the new custodian.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCustodianChange(address _proposedCustodian) external returns (bytes32 lockId) {\n        require(_proposedCustodian != address(0), \"zero address\");\n\n        (bytes32 preLockId, uint256 lockRequestIdx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                this.requestCustodianChange.selector,\n                _proposedCustodian\n            )\n        );\n\n        custodianChangeReqs[lockId] = CustodianChangeRequest({\n            proposedNew: _proposedCustodian\n        });\n\n        emit CustodianChangeRequested(lockId, msg.sender, _proposedCustodian, lockRequestIdx);\n    }\n\n    /** @notice  Confirms a pending change of the custodian associated with this contract.\n      *\n      * @dev  When called by the current custodian with a lock id associated with a\n      * pending custodian change, the `address custodian` member will be updated with the\n      * requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmCustodianChange(bytes32 _lockId) external onlyCustodian {\n        custodian = getCustodianChangeReq(_lockId);\n\n        delete custodianChangeReqs[_lockId];\n\n        emit CustodianChangeConfirmed(_lockId, custodian);\n    }\n\n    // PRIVATE FUNCTIONS\n    function getCustodianChangeReq(bytes32 _lockId) private view returns (address _proposedNew) {\n        CustodianChangeRequest storage changeRequest = custodianChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0), \"no such lockId\");\n\n        return changeRequest.proposedNew;\n    }\n\n    /// @dev  Emitted by successful `requestCustodianChange` calls.\n    event CustodianChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedCustodian,\n        uint256 _lockRequestIdx\n    );\n\n    /// @dev Emitted by successful `confirmCustodianChange` calls.\n    event CustodianChangeConfirmed(bytes32 _lockId, address _newCustodian);\n}\n"},"contracts/ERC20Proxy.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20Interface.sol\";\nimport \"./ERC20ImplUpgradeable.sol\";\n\n/** @title  Public interface to ERC20 compliant token.\n  *\n  * @notice  This contract is a permanent entry point to an ERC20 compliant\n  * system of contracts.\n  *\n  * @dev  This contract contains no business logic and instead\n  * delegates to an instance of ERC20Impl. This contract also has no storage\n  * that constitutes the operational state of the token. This contract is\n  * upgradeable in the sense that the `custodian` can update the\n  * `erc20Impl` address, thus redirecting the delegation of business logic.\n  * The `custodian` is also authorized to pass custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Proxy is ERC20Interface, ERC20ImplUpgradeable {\n\n    // MEMBERS\n    /// @notice  Returns the name of the token.\n    string public name;\n\n    /// @notice  Returns the symbol of the token.\n    string public symbol;\n\n    /// @notice  Returns the number of decimals the token uses.\n    uint8 public decimals;\n\n    // CONSTRUCTOR\n    constructor(\n        string memory _name,\n        string memory _symbol,\n        uint8 _decimals,\n        address _custodian\n    )\n        ERC20ImplUpgradeable(_custodian)\n    {\n        name = _name;\n        symbol = _symbol;\n        decimals = _decimals;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (ERC20Interface)\n    /** @notice  Returns the total token supply.\n      *\n      * @return  the total token supply.\n      */\n    function totalSupply() public override view returns (uint256) {\n        return erc20Impl.totalSupply();\n    }\n\n    /** @notice  Returns the account balance of another account with address\n      * `_owner`.\n      *\n      * @return  balance  the balance of account with address `_owner`.\n      */\n    function balanceOf(address _owner) public override view returns (uint256 balance) {\n        return erc20Impl.balanceOf(_owner);\n    }\n\n    /** @dev Internal use only.\n      */\n    function emitTransfer(address _from, address _to, uint256 _value) public onlyImpl {\n        emit Transfer(_from, _to, _value);\n    }\n\n    /** @notice  Transfers `_value` amount of tokens to address `_to`.\n      *\n      * @dev Will fire the `Transfer` event. Will revert if the `_from`\n      * account balance does not have enough tokens to spend.\n      *\n      * @return  success  true if transfer completes.\n      */\n    function transfer(address _to, uint256 _value) public override returns (bool success) {\n        return erc20Impl.transferWithSender(msg.sender, _to, _value);\n    }\n\n    /** @notice  Transfers `_value` amount of tokens from address `_from`\n      * to address `_to`.\n      *\n      * @dev  Will fire the `Transfer` event. Will revert unless the `_from`\n      * account has deliberately authorized the sender of the message\n      * via some mechanism.\n      *\n      * @return  success  true if transfer completes.\n      */\n    function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success) {\n        return erc20Impl.transferFromWithSender(msg.sender, _from, _to, _value);\n    }\n\n    /** @dev Internal use only.\n      */\n    function emitApproval(address _owner, address _spender, uint256 _value) public onlyImpl {\n        emit Approval(_owner, _spender, _value);\n    }\n\n    /** @notice  Allows `_spender` to withdraw from your account multiple times,\n      * up to the `_value` amount. If this function is called again it\n      * overwrites the current allowance with _value.\n      *\n      * @dev  Will fire the `Approval` event.\n      *\n      * @return  success  true if approval completes.\n      */\n    function approve(address _spender, uint256 _value) public override returns (bool success) {\n        return erc20Impl.approveWithSender(msg.sender, _spender, _value);\n    }\n\n    /** @notice Increases the amount `_spender` is allowed to withdraw from\n      * your account.\n      * This function is implemented to avoid the race condition in standard\n      * ERC20 contracts surrounding the `approve` method.\n      *\n      * @dev  Will fire the `Approval` event. This function should be used instead of\n      * `approve`.\n      *\n      * @return  success  true if approval completes.\n      */\n    function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {\n        return erc20Impl.increaseApprovalWithSender(msg.sender, _spender, _addedValue);\n    }\n\n    /** @notice  Decreases the amount `_spender` is allowed to withdraw from\n      * your account. This function is implemented to avoid the race\n      * condition in standard ERC20 contracts surrounding the `approve` method.\n      *\n      * @dev  Will fire the `Approval` event. This function should be used\n      * instead of `approve`.\n      *\n      * @return  success  true if approval completes.\n      */\n    function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool success) {\n        return erc20Impl.decreaseApprovalWithSender(msg.sender, _spender, _subtractedValue);\n    }\n\n    /** @notice  Returns how much `_spender` is currently allowed to spend from\n      * `_owner`'s balance.\n      *\n      * @return  remaining  the remaining allowance.\n      */\n    function allowance(address _owner, address _spender) public override view returns (uint256 remaining) {\n        return erc20Impl.allowance(_owner, _spender);\n    }\n}\n"},"contracts/ERC20Store.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20ImplUpgradeable.sol\";\n\n/** @title  ERC20 compliant token balance store.\n  *\n  * @notice  This contract serves as the store of balances, allowances, and\n  * supply for the ERC20 compliant token. No business logic exists here.\n  *\n  * @dev  This contract contains no business logic and instead\n  * is the final destination for any change in balances, allowances, or token\n  * supply. This contract is upgradeable in the sense that its custodian can\n  * update the `erc20Impl` address, thus redirecting the source of logic that\n  * determines how the balances will be updated.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Store is ERC20ImplUpgradeable {\n\n    // MEMBERS\n    /// @dev  The total token supply.\n    uint256 public totalSupply;\n\n    /// @dev  The mapping of balances.\n    mapping (address => uint256) public balances;\n\n    /// @dev  The mapping of allowances.\n    mapping (address => mapping (address => uint256)) public allowed;\n\n    // CONSTRUCTOR\n    constructor(address _custodian) ERC20ImplUpgradeable(_custodian) {\n        totalSupply = 0;\n    }\n\n\n    // PUBLIC FUNCTIONS\n    // (ERC20 Ledger)\n\n    /** @notice  The function to set the total supply of tokens.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update the total supply. The only authorized caller\n      * is the active implementation.\n      *\n      * @param _newTotalSupply the value to set as the new total supply\n      */\n    function setTotalSupply(\n        uint256 _newTotalSupply\n    )\n        public\n        onlyImpl\n    {\n        totalSupply = _newTotalSupply;\n    }\n\n    /** @notice  Sets how much `_owner` allows `_spender` to transfer on behalf\n      * of `_owner`.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update spending allowances. The only authorized caller\n      * is the active implementation.\n      *\n      * @param  _owner  The account that will allow an on-behalf-of spend.\n      * @param  _spender  The account that will spend on behalf of the owner.\n      * @param  _value  The limit of what can be spent.\n      */\n    function setAllowance(\n        address _owner,\n        address _spender,\n        uint256 _value\n    )\n        public\n        onlyImpl\n    {\n        allowed[_owner][_spender] = _value;\n    }\n\n    /** @notice  Sets the balance of `_owner` to `_newBalance`.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update balances. The only authorized caller\n      * is the active implementation.\n      *\n      * @param  _owner  The account that will hold a new balance.\n      * @param  _newBalance  The balance to set.\n      */\n    function setBalance(\n        address _owner,\n        uint256 _newBalance\n    )\n        public\n        onlyImpl\n    {\n        balances[_owner] = _newBalance;\n    }\n\n    /** @notice Adds `_balanceIncrease` to `_owner`'s balance.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update balances. The only authorized caller\n      * is the active implementation.\n      * WARNING: the caller is responsible for preventing overflow.\n      *\n      * @param  _owner  The account that will hold a new balance.\n      * @param  _balanceIncrease  The balance to add.\n      */\n    function addBalance(\n        address _owner,\n        uint256 _balanceIncrease\n    )\n        public\n        onlyImpl\n    {\n        unchecked {\n            // unchecked `+` as caller is responsible\n            // see occurrences of `.addBalance` in `ERC20Impl`\n            balances[_owner] = balances[_owner] + _balanceIncrease;\n        }\n    }\n}\n"},"contracts/ERC20Interface.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\ninterface ERC20Interface {\n  // METHODS\n\n  // NOTE:\n  //   public getter functions are not currently recognised as an\n  //   implementation of the matching abstract function by the compiler.\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#name\n  // function name() public view returns (string);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#symbol\n  // function symbol() public view returns (string);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply\n  // function decimals() public view returns (uint8);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply\n  function totalSupply() external view returns (uint256);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#balanceof\n  function balanceOf(address _owner) external view returns (uint256 balance);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer\n  function transfer(address _to, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transferfrom\n  function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approve\n  function approve(address _spender, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#allowance\n  function allowance(address _owner, address _spender) external view returns (uint256 remaining);\n\n  // EVENTS\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer-1\n  event Transfer(address indexed _from, address indexed _to, uint256 _value);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approval\n  event Approval(address indexed _owner, address indexed _spender, uint256 _value);\n}\n"},"contracts/ERC20ImplUpgradeable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./CustodianUpgradeable.sol\";\nimport \"./ERC20Impl.sol\";\n\n/** @title  A contract to inherit upgradeable token implementations.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * token implementations. It itself inherits from `CustodianUpgradable`\n  * as the upgrade process is controlled by the custodian.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a reference to the active token implementation, either\n  * to delegate calls to it, or authorize calls from it. This contract\n  * provides the mechanism for that implementation to be be replaced,\n  * which constitutes an implementation upgrade.\n  *\n  * @author Gemini Trust Company, LLC\n  */\nabstract contract ERC20ImplUpgradeable is CustodianUpgradeable {\n\n    // TYPES\n    /// @dev  The struct type for pending implementation changes.\n    struct ImplChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    // @dev  The reference to the active token implementation.\n    ERC20Impl public erc20Impl;\n\n    /// @dev  The map of lock ids to pending implementation changes.\n    mapping (bytes32 => ImplChangeRequest) public implChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(address _custodian) CustodianUpgradeable(_custodian) {\n        erc20Impl = ERC20Impl(address(0));\n    }\n\n    // MODIFIERS\n    modifier onlyImpl {\n        require(msg.sender == address(erc20Impl));\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n    /** @notice  Requests a change of the active implementation associated\n      * with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedImpl  The address of the new active implementation.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestImplChange(address _proposedImpl) public returns (bytes32 lockId) {\n        require(_proposedImpl != address(0));\n\n        lockId = generateLockId();\n\n        implChangeReqs[lockId] = ImplChangeRequest({\n            proposedNew: _proposedImpl\n        });\n\n        emit ImplChangeRequested(lockId, msg.sender, _proposedImpl);\n    }\n\n    /** @notice  Confirms a pending change of the active implementation\n      * associated with this contract.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending change, the `ERC20Impl erc20Impl` member will be updated\n      * with the requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmImplChange(bytes32 _lockId) public onlyCustodian {\n        erc20Impl = getImplChangeReq(_lockId);\n\n        delete implChangeReqs[_lockId];\n\n        emit ImplChangeConfirmed(_lockId, address(erc20Impl));\n    }\n\n    // PRIVATE FUNCTIONS\n    function getImplChangeReq(bytes32 _lockId) private view returns (ERC20Impl _proposedNew) {\n        ImplChangeRequest storage changeRequest = implChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0));\n\n        return ERC20Impl(changeRequest.proposedNew);\n    }\n\n    /// @dev  Emitted by successful `requestImplChange` calls.\n    event ImplChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedImpl\n    );\n\n    /// @dev Emitted by successful `confirmImplChange` calls.\n    event ImplChangeConfirmed(bytes32 _lockId, address _newImpl);\n}\n"},"contracts/CustodianUpgradeable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./LockRequestable.sol\";\n\n/** @title  A contract to inherit upgradeable custodianship.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * custodianship. That custodian may be an account or another contract.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a custodian to control some aspect of its functionality.\n  * This contract provides the mechanism for that custodianship to be\n  * passed from one custodian to the next.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract CustodianUpgradeable is LockRequestable {\n\n    // TYPES\n    /// @dev  The struct type for pending custodian changes.\n    struct CustodianChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address public custodian;\n\n    /// @dev  The map of lock ids to pending custodian changes.\n    mapping (bytes32 => CustodianChangeRequest) public custodianChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(\n        address _custodian\n    )\n      LockRequestable()\n    {\n        custodian = _custodian;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian);\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n\n    /** @notice  Requests a change of the custodian associated with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedCustodian  The address of the new custodian.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCustodianChange(address _proposedCustodian) public returns (bytes32 lockId) {\n        require(_proposedCustodian != address(0));\n\n        lockId = generateLockId();\n\n        custodianChangeReqs[lockId] = CustodianChangeRequest({\n            proposedNew: _proposedCustodian\n        });\n\n        emit CustodianChangeRequested(lockId, msg.sender, _proposedCustodian);\n    }\n\n    /** @notice  Confirms a pending change of the custodian associated with this contract.\n      *\n      * @dev  When called by the current custodian with a lock id associated with a\n      * pending custodian change, the `address custodian` member will be updated with the\n      * requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmCustodianChange(bytes32 _lockId) public onlyCustodian {\n        custodian = getCustodianChangeReq(_lockId);\n\n        delete custodianChangeReqs[_lockId];\n\n        emit CustodianChangeConfirmed(_lockId, custodian);\n    }\n\n    // PRIVATE FUNCTIONS\n    function getCustodianChangeReq(bytes32 _lockId) private view returns (address _proposedNew) {\n        CustodianChangeRequest storage changeRequest = custodianChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0));\n\n        return changeRequest.proposedNew;\n    }\n\n    /// @dev  Emitted by successful `requestCustodianChange` calls.\n    event CustodianChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedCustodian\n    );\n\n    /// @dev Emitted by successful `confirmCustodianChange` calls.\n    event CustodianChangeConfirmed(bytes32 _lockId, address _newCustodian);\n}\n"},"contracts/LockRequestable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\n/** @title  A contract for generating unique identifiers\n  *\n  * @notice  A contract that provides a identifier generation scheme,\n  * guaranteeing uniqueness across all contracts that inherit from it,\n  * as well as unpredictability of future identifiers.\n  *\n  * @dev  This contract is intended to be inherited by any contract that\n  * implements the callback software pattern for cooperative custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract LockRequestable {\n\n    // MEMBERS\n    /// @notice  the count of all invocations of `generateLockId`.\n    uint256 public lockRequestCount;\n\n    // CONSTRUCTOR\n    constructor() {\n        lockRequestCount = 0;\n    }\n\n    // FUNCTIONS\n    /** @notice  Returns a fresh unique identifier.\n      *\n      * @dev the generation scheme uses three components.\n      * First, the blockhash of the previous block.\n      * Second, the deployed address.\n      * Third, the next value of the counter.\n      * This ensure that identifiers are unique across all contracts\n      * following this scheme, and that future identifiers are\n      * unpredictable.\n      *\n      * @return lockId a 32-byte unique identifier.\n      */\n    function generateLockId() internal returns (bytes32 lockId) {\n        unchecked {\n            // unchecked `-` is safe as this can never be evaluated in the genesis (0) block\n            // unchecked `++` is safe as it is infeasible to exhaust 256-bit integer counter\n            return keccak256(\n                abi.encodePacked(\n                    blockhash(block.number - 1),\n                    address(this),\n                    ++lockRequestCount\n                )\n            );\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.30+commit.73712a01","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"libraries":{},"optimizer":{"runs":100000,"enabled":true},"evmVersion":"shanghai","remappings":["forge-std/=lib/forge-std/src/"]},"name":"PrintLimiter","fullyQualifiedName":"contracts/PrintLimiter.sol:PrintLimiter"},"abi":[{"type":"constructor","inputs":[{"name":"_erc20Impl","type":"address","internalType":"address"},{"name":"_custodian","type":"address","internalType":"address"},{"name":"_limitedPrinter","type":"address","internalType":"address"},{"name":"_initialCeiling","type":"uint256","internalType":"uint256"},{"name":"_initialSeizureLimit","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"CeilingLowered","type":"event","inputs":[{"name":"_lowerBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newCeiling","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CeilingRaiseConfirmed","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newCeiling","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CeilingRaiseLocked","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_lockRequestIdx","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitLowered","type":"event","inputs":[{"name":"_lowerBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newSeizureLimit","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitRaiseConfirmed","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newSeizureLimit","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitRaiseLocked","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_lockRequestIdx","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"confirmCeilingRaise","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmCustodianChangeProxy","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmPrintProxy","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmSeizureLimitRaise","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"custodian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"erc20Impl","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract ERC20Impl"}],"stateMutability":"view"},{"name":"limitedBurn","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"limitedPrint","type":"function","inputs":[{"name":"_receiver","type":"address","internalType":"address"},{"name":"_value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"limitedPrinter","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"lockRequestCount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"lowerCeiling","type":"function","inputs":[{"name":"_lowerBy","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"lowerSeizureLimit","type":"function","inputs":[{"name":"_lowerBy","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pendingRaiseMap","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"raiseBy","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"pendingSeizureLimitRaiseMap","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"raiseBy","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"requestCeilingRaise","type":"function","inputs":[{"name":"_raiseBy","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"lockId","type":"bytes32","internalType":"bytes32"}],"stateMutability":"nonpayable"},{"name":"requestSeizureLimitRaise","type":"function","inputs":[{"name":"_raiseBy","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"lockId","type":"bytes32","internalType":"bytes32"}],"stateMutability":"nonpayable"},{"name":"seizureLimit","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupplyCeiling","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_erc20Impl","type":"address"},{"internalType":"address","name":"_custodian","type":"address"},{"internalType":"address","name":"_limitedPrinter","type":"address"},{"internalType":"uint256","name":"_initialCeiling","type":"uint256"},{"internalType":"uint256","name":"_initialSeizureLimit","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_lowerBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_newCeiling","type":"uint256"}],"name":"CeilingLowered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_lockId","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"_raiseBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_newCeiling","type":"uint256"}],"name":"CeilingRaiseConfirmed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_lockId","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"_raiseBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_lockRequestIdx","type":"uint256"}],"name":"CeilingRaiseLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_lowerBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_newSeizureLimit","type":"uint256"}],"name":"SeizureLimitLowered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_lockId","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"_raiseBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_newSeizureLimit","type":"uint256"}],"name":"SeizureLimitRaiseConfirmed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"_lockId","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"_raiseBy","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_lockRequestIdx","type":"uint256"}],"name":"SeizureLimitRaiseLocked","type":"event"},{"inputs":[{"internalType":"bytes32","name":"_lockId","type":"bytes32"}],"name":"confirmCeilingRaise","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_lockId","type":"bytes32"}],"name":"confirmCustodianChangeProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_lockId","type":"bytes32"}],"name":"confirmPrintProxy","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_lockId","type":"bytes32"}],"name":"confirmSeizureLimitRaise","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"custodian","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Impl","outputs":[{"internalType":"contract ERC20Impl","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"limitedBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"limitedPrint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"limitedPrinter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockRequestCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lowerBy","type":"uint256"}],"name":"lowerCeiling","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_lowerBy","type":"uint256"}],"name":"lowerSeizureLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"pendingRaiseMap","outputs":[{"internalType":"uint256","name":"raiseBy","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"pendingSeizureLimitRaiseMap","outputs":[{"internalType":"uint256","name":"raiseBy","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_raiseBy","type":"uint256"}],"name":"requestCeilingRaise","outputs":[{"internalType":"bytes32","name":"lockId","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_raiseBy","type":"uint256"}],"name":"requestSeizureLimitRaise","outputs":[{"internalType":"bytes32","name":"lockId","type":"bytes32"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"seizureLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupplyCeiling","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}],"devdoc":{"author":"Gemini Trust Company, LLC","details":"This contract is a layer of indirection between an instance of ERC20Impl and a custodian. The functionality of the custodianship over the token implementation is preserved (printing and custodian changes), but this contract adds the ability for an additional key (the 'limited printer') to increase the token supply up to a ceiling, and this supply ceiling can only be raised by the custodian.","events":{"CeilingLowered(uint256,uint256)":{"details":"Emitted by successful `lowerCeiling` calls."},"CeilingRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmCeilingRaise` calls."},"CeilingRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestCeilingRaise` calls."},"SeizureLimitLowered(uint256,uint256)":{"details":"Emitted by successful `lowerSeizureLimit` calls."},"SeizureLimitRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmSeizureLimitRaise` calls."},"SeizureLimitRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestSeizureLimitRaise` calls."}},"kind":"dev","methods":{"confirmCeilingRaise(bytes32)":{"details":"When called by the custodian with a lock id associated with a pending ceiling increase, the amount requested is added to the current supply ceiling. NOTE: this function will not execute any raise that would overflow the supply ceiling, but it will not revert either.","params":{"_lockId":"The identifier of a pending ceiling raise request."}},"confirmCustodianChangeProxy(bytes32)":{"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of custodian changes.","params":{"_lockId":"The identifier of a pending custodian change request in the associated active token implementation."}},"confirmPrintProxy(bytes32)":{"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of unlimited printing.","params":{"_lockId":"The identifier of a pending print request in the associated active token implementation."}},"confirmSeizureLimitRaise(bytes32)":{"details":"When called by the custodian with a lock id associated with a pending seizure limit increase, the amount requested is added to the current limit. NOTE: this function will not execute any raise that would overflow the seizure limit, but it will not revert either.","params":{"_lockId":"The identifier of a pending seizure limit raise request."}},"limitedPrint(address,uint256)":{"details":"The function checks that the value to print does not exceed the supply ceiling when added to the current total supply. NOTE: printing to the zero address is disallowed.","params":{"_receiver":"The receiving address of the print.","_value":"The number of tokens to add to the total supply and the balance of the receiving address."}},"lowerCeiling(uint256)":{"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to increase the token supply.","params":{"_lowerBy":"The amount by which to lower the supply ceiling."}},"lowerSeizureLimit(uint256)":{"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to seize assets.","params":{"_lowerBy":"The amount by which to lower the seizure limit."}},"requestCeilingRaise(uint256)":{"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","params":{"_raiseBy":"The amount by which to raise the ceiling."},"returns":{"lockId":" A unique identifier for this request."}},"requestSeizureLimitRaise(uint256)":{"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","params":{"_raiseBy":"The amount by which to raise the seizure limit."},"returns":{"lockId":" A unique identifier for this request."}}},"stateVariables":{"custodian":{"details":"The address of the account or contract that acts as the custodian."},"erc20Impl":{"details":"The reference to the active token implementation."},"limitedPrinter":{"details":"The sole authorized caller of limited printing. This account is also authorized to lower the supply ceiling."},"pendingRaiseMap":{"details":"The map of lock ids to pending ceiling raises."},"pendingSeizureLimitRaiseMap":{"details":"The map of lock ids to pending seizure limit raises."},"seizureLimit":{"details":"The maximum that can be seized (burnt) through use of the limited burn feature. The value of the limit can only be increased by the custodian. The value of the limit can be decreased by the 'limited printer'."},"totalSupplyCeiling":{"details":"The maximum that the token supply can be increased to through use of the limited printing feature. The difference between the current total supply and the supply ceiling is what is available to the 'limited printer' account. The value of the ceiling can only be increased by the custodian."}},"title":"A contact to govern hybrid control over increases to the token supply.","version":1},"userdoc":{"kind":"user","methods":{"confirmCeilingRaise(bytes32)":{"notice":"Confirms a pending increase in the token supply."},"confirmCustodianChangeProxy(bytes32)":{"notice":"Pass-through control of custodian change confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."},"confirmPrintProxy(bytes32)":{"notice":"Pass-through control of print confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."},"confirmSeizureLimitRaise(bytes32)":{"notice":"Confirms a pending increase in the seizure limit."},"limitedPrint(address,uint256)":{"notice":"Increases the token supply, with the newly created tokens being added to the balance of the specified account."},"lockRequestCount()":{"notice":"the count of all invocations of `generatePreLockId`."},"lowerCeiling(uint256)":{"notice":"Lowers the supply ceiling, further constraining the bound of what can be printed by the limited printer."},"lowerSeizureLimit(uint256)":{"notice":"Lowers the seizure limit, further constraining the bound of what can be seized (burnt) by the limited printer."},"requestCeilingRaise(uint256)":{"notice":"Requests an increase to the supply ceiling."},"requestSeizureLimitRaise(uint256)":{"notice":"Requests an increase to the seizure limit."}},"notice":"A contract that acts as a custodian of the active token implementation, and an intermediary between it and the ‘true’ custodian. It preserves the functionality of direct custodianship as well as granting limited control of token supply increases to an additional key.","version":1}},"settings":{"compilationTarget":{"contracts/PrintLimiter.sol":"PrintLimiter"},"evmVersion":"shanghai","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":100000},"remappings":[":forge-std/=lib/forge-std/src/"]},"sources":{"contracts/CustodianUpgradeable.sol":{"keccak256":"0xec12d8a933801a5540d1d3f33014a2674fce159ac5c5c293ae456118b2a6ffe9","license":"UNLICENSED","urls":["bzz-raw://5c22e1bd87d78b4d13ab1be01e6006a5bebf20e300db2eac38370c05b3781c43","dweb:/ipfs/QmUaxjk3LVA6UDXbycG2aYAQyYBKKTvQpuusp9QeCe3pME"]},"contracts/CustodianUpgradeableV1dot1.sol":{"keccak256":"0xe4d4a08714522c58f750ee4a5b1fe599169d248afba89f135801d9663d07ced5","license":"UNLICENSED","urls":["bzz-raw://71eeee97fd0492b19cf6a339b305ccda77fc48f823e7f7f0de8ed3c1b5e28963","dweb:/ipfs/QmRmE3LEZ82GHqdSgG49PomFsbqYpeg8o8cyfLAHS8gJea"]},"contracts/ERC20Impl.sol":{"keccak256":"0x28994b983f9cc476de866c39ac9e71e69373dd88e3a764e55afdb26c600332ce","license":"UNLICENSED","urls":["bzz-raw://acb53286dba2b61976d4908e9176a0c6532a5537eda616576369efe7a8cbed62","dweb:/ipfs/QmYESzkaeb76AU9hktrVSFk2yzKvHuYJsJnYjw7QY8LmN3"]},"contracts/ERC20ImplUpgradeable.sol":{"keccak256":"0x5de6ecbc2eb9188e4541dc4659ee2c389e9f855e26d896976a5d7bdbb546a9e9","license":"UNLICENSED","urls":["bzz-raw://a99ca65203b7366e5089484b37107d3585c5915d21b1c807c1825efe63a12786","dweb:/ipfs/QmeShSCPMCLAKznCAnAAt5gBfvKxFWsWacKbZrx7vu9sZn"]},"contracts/ERC20Interface.sol":{"keccak256":"0x7872d028ae35e1adf3ca57e032888254983dce8c7df276b5a6f5cc8476cb0969","license":"UNLICENSED","urls":["bzz-raw://7420c36a5b5665d86c98ebecc2e1410705f662ab770a4c3316bb5b9aac966f18","dweb:/ipfs/QmaZ4k1rbm9LG2tj2bU7JHzFXUxu3yHAot567o8pa4FgTK"]},"contracts/ERC20Proxy.sol":{"keccak256":"0xc25caf6187f951f721f8958b380e211b4beab56d08febbcd71711c7dee20d450","license":"UNLICENSED","urls":["bzz-raw://859e8c7f14b37bb0143190e12889e3cc74517188b6f277dd4e740885e0ef3dc5","dweb:/ipfs/QmeU29JrHpqzNzEBpiL8JMBoLAy4DizcGX7V8EVnm14Hxh"]},"contracts/ERC20Store.sol":{"keccak256":"0x9d3aff9e93cb489be4b061793224d929db7900390d4d88831cd0f4f8cb11fb09","license":"UNLICENSED","urls":["bzz-raw://6ae632cabb50b1437db3628433d5bdffb20edd4cad15ab80df259235ba60b8c9","dweb:/ipfs/QmYjoZZVdioMW1F127QoGW4cBJ1oTAkvQ8YvzkJkxeZun8"]},"contracts/LockRequestable.sol":{"keccak256":"0x7cbb420ccffa171a9db6557c0c21629968df1b90f11d9aedf9fdb50f1f777a1d","license":"UNLICENSED","urls":["bzz-raw://f23127f71d75faea6ed8251019b958d0a3aac311a01b030659acac1520b4b1d8","dweb:/ipfs/QmW4Xay821UHHLhosMJx6QrZ3bRssBVdB5Enoy5444ZiLY"]},"contracts/LockRequestableV1dot1.sol":{"keccak256":"0x5ae098cedf263ee5a0e55f03b9c9cd15cf6fd5b75e42dfcf83928c6c50f6e43f","license":"UNLICENSED","urls":["bzz-raw://c57bba880e1cc1469af929c698c5fe793f37270ec6e7782c953a31fa06eb4f33","dweb:/ipfs/QmfXBxRAA83nRpyoDWqx1a94aKRTy7YZS4MJBX7beHH6jd"]},"contracts/PrintLimiter.sol":{"keccak256":"0x1ac5aa634b534a7ebf8bd7976b2585090e29b292eb336a9780612121ab07b371","license":"UNLICENSED","urls":["bzz-raw://5ab43057ebf2b341482803da6bd7026835a5903d8b696483fe0625f24e0d6dcc","dweb:/ipfs/QmZNNBVcYhScyKKBJnct1v7zr7JVkyzmpPu6kU2nCriqAL"]}},"version":1},"storageLayout":{"types":{"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_struct(Raise)1848_storage":{"label":"struct PrintLimiter.Raise","members":[{"slot":"0","type":"t_uint256","astId":1847,"label":"raiseBy","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(Raise)1848_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct PrintLimiter.Raise)","value":"t_struct(Raise)1848_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":1794,"label":"lockRequestCount","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"1","type":"t_uint256","astId":1861,"label":"totalSupplyCeiling","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"2","type":"t_uint256","astId":1864,"label":"seizureLimit","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"3","type":"t_mapping(t_bytes32,t_struct(Raise)1848_storage)","astId":1870,"label":"pendingRaiseMap","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"4","type":"t_mapping(t_bytes32,t_struct(Raise)1848_storage)","astId":1876,"label":"pendingSeizureLimitRaiseMap","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"A contract that acts as a custodian of the active token implementation, and an intermediary between it and the ‘true’ custodian. It preserves the functionality of direct custodianship as well as granting limited control of token supply increases to an additional key.","methods":{"lockRequestCount()":{"notice":"the count of all invocations of `generatePreLockId`."},"lowerCeiling(uint256)":{"notice":"Lowers the supply ceiling, further constraining the bound of what can be printed by the limited printer."},"confirmPrintProxy(bytes32)":{"notice":"Pass-through control of print confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."},"lowerSeizureLimit(uint256)":{"notice":"Lowers the seizure limit, further constraining the bound of what can be seized (burnt) by the limited printer."},"confirmCeilingRaise(bytes32)":{"notice":"Confirms a pending increase in the token supply."},"requestCeilingRaise(uint256)":{"notice":"Requests an increase to the supply ceiling."},"limitedPrint(address,uint256)":{"notice":"Increases the token supply, with the newly created tokens being added to the balance of the specified account."},"confirmSeizureLimitRaise(bytes32)":{"notice":"Confirms a pending increase in the seizure limit."},"requestSeizureLimitRaise(uint256)":{"notice":"Requests an increase to the seizure limit."},"confirmCustodianChangeProxy(bytes32)":{"notice":"Pass-through control of custodian change confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."}},"version":1},"devdoc":{"kind":"dev","title":"A contact to govern hybrid control over increases to the token supply.","author":"Gemini Trust Company, LLC","events":{"CeilingLowered(uint256,uint256)":{"details":"Emitted by successful `lowerCeiling` calls."},"SeizureLimitLowered(uint256,uint256)":{"details":"Emitted by successful `lowerSeizureLimit` calls."},"CeilingRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestCeilingRaise` calls."},"CeilingRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmCeilingRaise` calls."},"SeizureLimitRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestSeizureLimitRaise` calls."},"SeizureLimitRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmSeizureLimitRaise` calls."}},"details":"This contract is a layer of indirection between an instance of ERC20Impl and a custodian. The functionality of the custodianship over the token implementation is preserved (printing and custodian changes), but this contract adds the ability for an additional key (the 'limited printer') to increase the token supply up to a ceiling, and this supply ceiling can only be raised by the custodian.","methods":{"lowerCeiling(uint256)":{"params":{"_lowerBy":"The amount by which to lower the supply ceiling."},"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to increase the token supply."},"confirmPrintProxy(bytes32)":{"params":{"_lockId":"The identifier of a pending print request in the associated active token implementation."},"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of unlimited printing."},"lowerSeizureLimit(uint256)":{"params":{"_lowerBy":"The amount by which to lower the seizure limit."},"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to seize assets."},"confirmCeilingRaise(bytes32)":{"params":{"_lockId":"The identifier of a pending ceiling raise request."},"details":"When called by the custodian with a lock id associated with a pending ceiling increase, the amount requested is added to the current supply ceiling. NOTE: this function will not execute any raise that would overflow the supply ceiling, but it will not revert either."},"requestCeilingRaise(uint256)":{"params":{"_raiseBy":"The amount by which to raise the ceiling."},"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","returns":{"lockId":" A unique identifier for this request."}},"limitedPrint(address,uint256)":{"params":{"_value":"The number of tokens to add to the total supply and the balance of the receiving address.","_receiver":"The receiving address of the print."},"details":"The function checks that the value to print does not exceed the supply ceiling when added to the current total supply. NOTE: printing to the zero address is disallowed."},"confirmSeizureLimitRaise(bytes32)":{"params":{"_lockId":"The identifier of a pending seizure limit raise request."},"details":"When called by the custodian with a lock id associated with a pending seizure limit increase, the amount requested is added to the current limit. NOTE: this function will not execute any raise that would overflow the seizure limit, but it will not revert either."},"requestSeizureLimitRaise(uint256)":{"params":{"_raiseBy":"The amount by which to raise the seizure limit."},"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","returns":{"lockId":" A unique identifier for this request."}},"confirmCustodianChangeProxy(bytes32)":{"params":{"_lockId":"The identifier of a pending custodian change request in the associated active token implementation."},"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of custodian changes."}},"version":1,"stateVariables":{"custodian":{"details":"The address of the account or contract that acts as the custodian."},"erc20Impl":{"details":"The reference to the active token implementation."},"seizureLimit":{"details":"The maximum that can be seized (burnt) through use of the limited burn feature. The value of the limit can only be increased by the custodian. The value of the limit can be decreased by the 'limited printer'."},"limitedPrinter":{"details":"The sole authorized caller of limited printing. This account is also authorized to lower the supply ceiling."},"pendingRaiseMap":{"details":"The map of lock ids to pending ceiling raises."},"totalSupplyCeiling":{"details":"The maximum that the token supply can be increased to through use of the limited printing feature. The difference between the current total supply and the supply ceiling is what is available to the 'limited printer' account. The value of the ceiling can only be increased by the custodian."},"pendingSeizureLimitRaiseMap":{"details":"The map of lock ids to pending seizure limit raises."}}},"sourceIds":{"contracts/ERC20Impl.sol":{"id":2},"contracts/ERC20Proxy.sol":{"id":5},"contracts/ERC20Store.sol":{"id":6},"contracts/PrintLimiter.sol":{"id":9},"contracts/ERC20Interface.sol":{"id":4},"contracts/LockRequestable.sol":{"id":7},"contracts/CustodianUpgradeable.sol":{"id":0},"contracts/ERC20ImplUpgradeable.sol":{"id":3},"contracts/LockRequestableV1dot1.sol":{"id":8},"contracts/CustodianUpgradeableV1dot1.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/ERC20Impl.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./CustodianUpgradeableV1dot1.sol\";\nimport \"./ERC20Proxy.sol\";\nimport \"./ERC20Store.sol\";\n\n/** @title  ERC20 compliant token intermediary contract holding core logic.\n  *\n  * @notice  This contract serves as an intermediary between the exposed ERC20\n  * interface in ERC20Proxy and the store of balances in ERC20Store. This\n  * contract contains core logic that the proxy can delegate to\n  * and that the store is called by.\n  *\n  * @dev  This contract contains the core logic to implement the\n  * ERC20 specification as well as several extensions.\n  * 1. Changes to the token supply.\n  * 2. Batched transfers.\n  * 3. Relative changes to spending approvals.\n  * 4. Delegated transfer control ('sweeping').\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Impl is CustodianUpgradeableV1dot1 {\n\n    // TYPES\n    /// @dev  The struct type for pending increases to the token supply (print).\n    struct PendingPrint {\n        address receiver;\n        uint256 value;\n    }\n\n    // MEMBERS\n    /// @dev  The reference to the proxy.\n    ERC20Proxy immutable public erc20Proxy;\n\n    /// @dev  The reference to the store.\n    ERC20Store immutable public erc20Store;\n\n    /// @dev  The map of lock ids to pending token increases.\n    mapping (bytes32 => PendingPrint) public pendingPrintMap;\n\n    // CONSTRUCTOR\n    constructor(\n          address _erc20Proxy,\n          address _erc20Store,\n          address _custodian\n    )\n        CustodianUpgradeableV1dot1(_custodian)\n    {\n        erc20Proxy = ERC20Proxy(_erc20Proxy);\n        erc20Store = ERC20Store(_erc20Store);\n    }\n\n    // MODIFIERS\n    modifier onlyProxy {\n        require(msg.sender == address(erc20Proxy), \"unauthorized\");\n        _;\n    }\n\n\n    /** @notice  Core logic of the ERC20 `approve` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has an `approve` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval in proxy.\n      */\n    function approveWithSender(\n        address _sender,\n        address _spender,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        erc20Store.setAllowance(_sender, _spender, _value);\n        erc20Proxy.emitApproval(_sender, _spender, _value);\n        return true;\n    }\n\n    /** @notice  Core logic of the `increaseApproval` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has an `increaseApproval` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval.\n      */\n    function increaseApprovalWithSender(\n        address _sender,\n        address _spender,\n        uint256 _addedValue\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        uint256 currentAllowance = erc20Store.allowed(_sender, _spender);\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newAllowance = currentAllowance + _addedValue;\n            require(newAllowance >= currentAllowance, \"overflow\");\n\n            erc20Store.setAllowance(_sender, _spender, newAllowance);\n            erc20Proxy.emitApproval(_sender, _spender, newAllowance);\n            return true;\n        }\n    }\n\n    /** @notice  Core logic of the `decreaseApproval` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `decreaseApproval` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: approvals for the zero address (unspendable) are disallowed.\n      *\n      * @param  _sender  The address initiating the approval.\n      */\n    function decreaseApprovalWithSender(\n        address _sender,\n        address _spender,\n        uint256 _subtractedValue\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_spender != address(0), \"zero address\"); // disallow unspendable approvals\n        uint256 currentAllowance = erc20Store.allowed(_sender, _spender);\n\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newAllowance = currentAllowance - _subtractedValue;\n            require(newAllowance <= currentAllowance, \"overflow\");\n\n            erc20Store.setAllowance(_sender, _spender, newAllowance);\n            erc20Proxy.emitApproval(_sender, _spender, newAllowance);\n        }\n\n        return true;\n    }\n\n    /** @notice  Requests an increase in the token supply, with the newly created\n      * tokens to be added to the balance of the specified account.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      * NOTE: printing to the zero address is disallowed.\n      *\n      * @param  _receiver  The receiving address of the print, if confirmed.\n      * @param  _value  The number of tokens to add to the total supply and the\n      * balance of the receiving address, if confirmed.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestPrint(address _receiver, uint256 _value) external returns (bytes32 lockId) {\n        require(_receiver != address(0), \"zero address\");\n\n        (bytes32 preLockId, uint256 lockRequestIdx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                this.requestPrint.selector,\n                _receiver,\n                _value\n            )\n        );\n\n        pendingPrintMap[lockId] = PendingPrint({\n            receiver: _receiver,\n            value: _value\n        });\n\n        emit PrintingLocked(lockId, _receiver, _value, lockRequestIdx);\n    }\n\n    function _executePrint(address _receiver, uint256 _value) private returns (bool success) {\n        uint256 supply = erc20Store.totalSupply();\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newSupply = supply + _value;\n            if (newSupply >= supply) {\n                erc20Store.setTotalSupply(newSupply);\n                erc20Store.addBalance(_receiver, _value);\n\n                erc20Proxy.emitTransfer(address(0), _receiver, _value);\n                return true;\n            }\n        }\n    }\n\n    function executePrint(address _receiver, uint256 _value) external onlyCustodian {\n        require(_receiver != address(0), \"zero address\");\n        _executePrint(_receiver, _value);\n    }\n\n    /** @notice  Confirms a pending increase in the token supply.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending increase, the amount requested to be printed in the print request\n      * is printed to the receiving address specified in that same request.\n      * NOTE: this function will not execute any print that would overflow the\n      * total supply, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending print request.\n      */\n    function confirmPrint(bytes32 _lockId) external onlyCustodian {\n        PendingPrint storage print = pendingPrintMap[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        address receiver = print.receiver;\n        require (receiver != address(0), \"no such lockId\");\n        uint256 value = print.value;\n\n        delete pendingPrintMap[_lockId];\n\n        if (_executePrint(receiver, value)) {\n            emit PrintingConfirmed(_lockId, receiver, value);\n        }\n    }\n\n    function _executeBurn(address _owner, uint256 _value) private returns (bool success) {\n        uint256 balanceOfSender = erc20Store.balances(_owner);\n        require(_value <= balanceOfSender, \"insufficient balance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfSender`\n            erc20Store.setBalance(_owner, balanceOfSender - _value);\n            // unchecked `-` is safe as the global invariants is that\n            // the sum of all balances equals the total supply, therefore\n            // as `_value <= balanceOfSender`, then `_value <= totalSupply`\n            erc20Store.setTotalSupply(erc20Store.totalSupply() - _value);\n        }\n\n        erc20Proxy.emitTransfer(_owner, address(0), _value);\n\n        return true;\n    }\n\n    /** @notice  Burns the specified value from the sender's balance.\n      *\n      * @dev  Sender's balanced is subtracted by the amount they wish to burn.\n      *\n      * @param  _value  The amount to burn.\n      *\n      * @return  success  true if the burn succeeded.\n      */\n    function burn(uint256 _value) external returns (bool success) {\n        return _executeBurn(msg.sender, _value);\n    }\n\n    /** @notice  Burns the specified value from the owner's balance.\n      *\n      * @dev  Owner's balance is subtracted by the amount the custodian wishes to burn.\n      *\n      * @param  _owner  The owner of the tokens.\n      * @param  _value  The amount to burn.\n      */\n    function burn(address _owner, uint256 _value) external onlyCustodian {\n        _executeBurn(_owner, _value);\n    }\n\n    /** @notice  A function for a sender to issue multiple transfers to multiple\n      * different addresses at once. This function is implemented for gas\n      * considerations when someone wishes to transfer, as one transaction is\n      * cheaper than issuing several distinct individual `transfer` transactions.\n      *\n      * @dev  By specifying a set of destination addresses and values, the\n      * sender can issue one transaction to transfer multiple amounts to\n      * distinct addresses, rather than issuing each as a separate\n      * transaction. The `_tos` and `_values` arrays must be equal length, and\n      * an index in one array corresponds to the same index in the other array\n      * (e.g. `_tos[0]` will receive `_values[0]`, `_tos[1]` will receive\n      * `_values[1]`, and so on.)\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _tos  The destination addresses to receive the transfers.\n      * @param  _values  The values for each destination address.\n      * @return  success  If transfers succeeded.\n      */\n    function batchTransfer(address[] calldata _tos, uint256[] calldata _values) external returns (bool success) {\n        require(_tos.length == _values.length, \"inconsistent length\");\n\n        uint256 numTransfers = _tos.length;\n        uint256 senderBalance = erc20Store.balances(msg.sender);\n\n        for (uint256 i = 0; i < numTransfers; i++) {\n          address to = _tos[i];\n          require(to != address(0), \"zero address\");\n          uint256 v = _values[i];\n          require(senderBalance >= v, \"insufficient balance\");\n\n          if (msg.sender != to) {\n            senderBalance -= v;\n            erc20Store.addBalance(to, v);\n          }\n          erc20Proxy.emitTransfer(msg.sender, to, v);\n        }\n\n        erc20Store.setBalance(msg.sender, senderBalance);\n\n        return true;\n    }\n\n    /** @notice  Core logic of the ERC20 `transferFrom` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `transferFrom` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _sender  The address initiating the transfer in proxy.\n      */\n    function transferFromWithSender(\n        address _sender,\n        address _from,\n        address _to,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_to != address(0), \"zero address\"); // ensure burn is the cannonical transfer to 0x0\n\n        uint256 balanceOfFrom = erc20Store.balances(_from);\n        require(_value <= balanceOfFrom, \"insufficient balance\");\n\n        uint256 senderAllowance = erc20Store.allowed(_from, _sender);\n        require(_value <= senderAllowance, \"insufficient allowance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfFrom`\n            erc20Store.setBalance(_from, balanceOfFrom - _value);\n        }\n        erc20Store.addBalance(_to, _value);\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= senderAllowance`\n            erc20Store.setAllowance(_from, _sender, senderAllowance - _value);\n        }\n\n        erc20Proxy.emitTransfer(_from, _to, _value);\n\n        return true;\n    }\n\n    /** @notice  Core logic of the ERC20 `transfer` function.\n      *\n      * @dev  This function can only be called by the referenced proxy,\n      * which has a `transfer` function.\n      * Every argument passed to that function as well as the original\n      * `msg.sender` gets passed to this function.\n      * NOTE: transfers to the zero address are disallowed.\n      *\n      * @param  _sender  The address initiating the transfer in proxy.\n      */\n    function transferWithSender(\n        address _sender,\n        address _to,\n        uint256 _value\n    )\n        external\n        onlyProxy\n        returns (bool success)\n    {\n        require(_to != address(0), \"zero address\"); // ensure burn is the cannonical transfer to 0x0\n\n        uint256 balanceOfSender = erc20Store.balances(_sender);\n        require(_value <= balanceOfSender, \"insufficient balance\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= balanceOfSender`\n            erc20Store.setBalance(_sender, balanceOfSender - _value);\n        }\n        erc20Store.addBalance(_to, _value);\n\n        erc20Proxy.emitTransfer(_sender, _to, _value);\n\n        return true;\n    }\n\n    // METHODS (ERC20 sub interface impl.)\n    /// @notice  Core logic of the ERC20 `totalSupply` function.\n    function totalSupply() external view returns (uint256) {\n        return erc20Store.totalSupply();\n    }\n\n    /// @notice  Core logic of the ERC20 `balanceOf` function.\n    function balanceOf(address _owner) external view returns (uint256 balance) {\n        return erc20Store.balances(_owner);\n    }\n\n    /// @notice  Core logic of the ERC20 `allowance` function.\n    function allowance(address _owner, address _spender) external view returns (uint256 remaining) {\n        return erc20Store.allowed(_owner, _spender);\n    }\n\n    // EVENTS\n    /// @dev  Emitted by successful `requestPrint` calls.\n    event PrintingLocked(bytes32 _lockId, address _receiver, uint256 _value, uint256 _lockRequestIdx);\n    /// @dev Emitted by successful `confirmPrint` calls.\n    event PrintingConfirmed(bytes32 _lockId, address _receiver, uint256 _value);\n}\n"},"contracts/ERC20Proxy.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20Interface.sol\";\nimport \"./ERC20ImplUpgradeable.sol\";\n\n/** @title  Public interface to ERC20 compliant token.\n  *\n  * @notice  This contract is a permanent entry point to an ERC20 compliant\n  * system of contracts.\n  *\n  * @dev  This contract contains no business logic and instead\n  * delegates to an instance of ERC20Impl. This contract also has no storage\n  * that constitutes the operational state of the token. This contract is\n  * upgradeable in the sense that the `custodian` can update the\n  * `erc20Impl` address, thus redirecting the delegation of business logic.\n  * The `custodian` is also authorized to pass custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Proxy is ERC20Interface, ERC20ImplUpgradeable {\n\n    // MEMBERS\n    /// @notice  Returns the name of the token.\n    string public name;\n\n    /// @notice  Returns the symbol of the token.\n    string public symbol;\n\n    /// @notice  Returns the number of decimals the token uses.\n    uint8 public decimals;\n\n    // CONSTRUCTOR\n    constructor(\n        string memory _name,\n        string memory _symbol,\n        uint8 _decimals,\n        address _custodian\n    )\n        ERC20ImplUpgradeable(_custodian)\n    {\n        name = _name;\n        symbol = _symbol;\n        decimals = _decimals;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (ERC20Interface)\n    /** @notice  Returns the total token supply.\n      *\n      * @return  the total token supply.\n      */\n    function totalSupply() public override view returns (uint256) {\n        return erc20Impl.totalSupply();\n    }\n\n    /** @notice  Returns the account balance of another account with address\n      * `_owner`.\n      *\n      * @return  balance  the balance of account with address `_owner`.\n      */\n    function balanceOf(address _owner) public override view returns (uint256 balance) {\n        return erc20Impl.balanceOf(_owner);\n    }\n\n    /** @dev Internal use only.\n      */\n    function emitTransfer(address _from, address _to, uint256 _value) public onlyImpl {\n        emit Transfer(_from, _to, _value);\n    }\n\n    /** @notice  Transfers `_value` amount of tokens to address `_to`.\n      *\n      * @dev Will fire the `Transfer` event. Will revert if the `_from`\n      * account balance does not have enough tokens to spend.\n      *\n      * @return  success  true if transfer completes.\n      */\n    function transfer(address _to, uint256 _value) public override returns (bool success) {\n        return erc20Impl.transferWithSender(msg.sender, _to, _value);\n    }\n\n    /** @notice  Transfers `_value` amount of tokens from address `_from`\n      * to address `_to`.\n      *\n      * @dev  Will fire the `Transfer` event. Will revert unless the `_from`\n      * account has deliberately authorized the sender of the message\n      * via some mechanism.\n      *\n      * @return  success  true if transfer completes.\n      */\n    function transferFrom(address _from, address _to, uint256 _value) public override returns (bool success) {\n        return erc20Impl.transferFromWithSender(msg.sender, _from, _to, _value);\n    }\n\n    /** @dev Internal use only.\n      */\n    function emitApproval(address _owner, address _spender, uint256 _value) public onlyImpl {\n        emit Approval(_owner, _spender, _value);\n    }\n\n    /** @notice  Allows `_spender` to withdraw from your account multiple times,\n      * up to the `_value` amount. If this function is called again it\n      * overwrites the current allowance with _value.\n      *\n      * @dev  Will fire the `Approval` event.\n      *\n      * @return  success  true if approval completes.\n      */\n    function approve(address _spender, uint256 _value) public override returns (bool success) {\n        return erc20Impl.approveWithSender(msg.sender, _spender, _value);\n    }\n\n    /** @notice Increases the amount `_spender` is allowed to withdraw from\n      * your account.\n      * This function is implemented to avoid the race condition in standard\n      * ERC20 contracts surrounding the `approve` method.\n      *\n      * @dev  Will fire the `Approval` event. This function should be used instead of\n      * `approve`.\n      *\n      * @return  success  true if approval completes.\n      */\n    function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {\n        return erc20Impl.increaseApprovalWithSender(msg.sender, _spender, _addedValue);\n    }\n\n    /** @notice  Decreases the amount `_spender` is allowed to withdraw from\n      * your account. This function is implemented to avoid the race\n      * condition in standard ERC20 contracts surrounding the `approve` method.\n      *\n      * @dev  Will fire the `Approval` event. This function should be used\n      * instead of `approve`.\n      *\n      * @return  success  true if approval completes.\n      */\n    function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool success) {\n        return erc20Impl.decreaseApprovalWithSender(msg.sender, _spender, _subtractedValue);\n    }\n\n    /** @notice  Returns how much `_spender` is currently allowed to spend from\n      * `_owner`'s balance.\n      *\n      * @return  remaining  the remaining allowance.\n      */\n    function allowance(address _owner, address _spender) public override view returns (uint256 remaining) {\n        return erc20Impl.allowance(_owner, _spender);\n    }\n}\n"},"contracts/ERC20Store.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20ImplUpgradeable.sol\";\n\n/** @title  ERC20 compliant token balance store.\n  *\n  * @notice  This contract serves as the store of balances, allowances, and\n  * supply for the ERC20 compliant token. No business logic exists here.\n  *\n  * @dev  This contract contains no business logic and instead\n  * is the final destination for any change in balances, allowances, or token\n  * supply. This contract is upgradeable in the sense that its custodian can\n  * update the `erc20Impl` address, thus redirecting the source of logic that\n  * determines how the balances will be updated.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract ERC20Store is ERC20ImplUpgradeable {\n\n    // MEMBERS\n    /// @dev  The total token supply.\n    uint256 public totalSupply;\n\n    /// @dev  The mapping of balances.\n    mapping (address => uint256) public balances;\n\n    /// @dev  The mapping of allowances.\n    mapping (address => mapping (address => uint256)) public allowed;\n\n    // CONSTRUCTOR\n    constructor(address _custodian) ERC20ImplUpgradeable(_custodian) {\n        totalSupply = 0;\n    }\n\n\n    // PUBLIC FUNCTIONS\n    // (ERC20 Ledger)\n\n    /** @notice  The function to set the total supply of tokens.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update the total supply. The only authorized caller\n      * is the active implementation.\n      *\n      * @param _newTotalSupply the value to set as the new total supply\n      */\n    function setTotalSupply(\n        uint256 _newTotalSupply\n    )\n        public\n        onlyImpl\n    {\n        totalSupply = _newTotalSupply;\n    }\n\n    /** @notice  Sets how much `_owner` allows `_spender` to transfer on behalf\n      * of `_owner`.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update spending allowances. The only authorized caller\n      * is the active implementation.\n      *\n      * @param  _owner  The account that will allow an on-behalf-of spend.\n      * @param  _spender  The account that will spend on behalf of the owner.\n      * @param  _value  The limit of what can be spent.\n      */\n    function setAllowance(\n        address _owner,\n        address _spender,\n        uint256 _value\n    )\n        public\n        onlyImpl\n    {\n        allowed[_owner][_spender] = _value;\n    }\n\n    /** @notice  Sets the balance of `_owner` to `_newBalance`.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update balances. The only authorized caller\n      * is the active implementation.\n      *\n      * @param  _owner  The account that will hold a new balance.\n      * @param  _newBalance  The balance to set.\n      */\n    function setBalance(\n        address _owner,\n        uint256 _newBalance\n    )\n        public\n        onlyImpl\n    {\n        balances[_owner] = _newBalance;\n    }\n\n    /** @notice Adds `_balanceIncrease` to `_owner`'s balance.\n      *\n      * @dev  Intended for use by token implementation functions\n      * that update balances. The only authorized caller\n      * is the active implementation.\n      * WARNING: the caller is responsible for preventing overflow.\n      *\n      * @param  _owner  The account that will hold a new balance.\n      * @param  _balanceIncrease  The balance to add.\n      */\n    function addBalance(\n        address _owner,\n        uint256 _balanceIncrease\n    )\n        public\n        onlyImpl\n    {\n        unchecked {\n            // unchecked `+` as caller is responsible\n            // see occurrences of `.addBalance` in `ERC20Impl`\n            balances[_owner] = balances[_owner] + _balanceIncrease;\n        }\n    }\n}\n"},"contracts/PrintLimiter.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./ERC20Impl.sol\";\nimport \"./LockRequestableV1dot1.sol\";\n\n/** @title  A contact to govern hybrid control over increases to the token supply.\n  *\n  * @notice  A contract that acts as a custodian of the active token\n  * implementation, and an intermediary between it and the ‘true’ custodian.\n  * It preserves the functionality of direct custodianship as well as granting\n  * limited control of token supply increases to an additional key.\n  *\n  * @dev  This contract is a layer of indirection between an instance of\n  * ERC20Impl and a custodian. The functionality of the custodianship over\n  * the token implementation is preserved (printing and custodian changes),\n  * but this contract adds the ability for an additional key\n  * (the 'limited printer') to increase the token supply up to a ceiling,\n  * and this supply ceiling can only be raised by the custodian.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\ncontract PrintLimiter is LockRequestableV1dot1 {\n\n    // TYPES\n    /// @dev The struct type for ceiling/limit raises.\n    struct Raise {\n        uint256 raiseBy;\n    }\n\n    // MEMBERS\n    /// @dev  The reference to the active token implementation.\n    ERC20Impl immutable public erc20Impl;\n\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address immutable public custodian;\n\n    /** @dev  The sole authorized caller of limited printing.\n      * This account is also authorized to lower the supply ceiling.\n      */\n    address immutable public limitedPrinter;\n\n    /** @dev  The maximum that the token supply can be increased to\n      * through use of the limited printing feature.\n      * The difference between the current total supply and the supply\n      * ceiling is what is available to the 'limited printer' account.\n      * The value of the ceiling can only be increased by the custodian.\n      */\n    uint256 public totalSupplyCeiling;\n\n    /** @dev  The maximum that can be seized (burnt) through use of\n      * the limited burn feature.\n      * The value of the limit can only be increased by the custodian.\n      * The value of the limit can be decreased by the 'limited printer'.\n      */\n    uint256 public seizureLimit;\n\n    /// @dev  The map of lock ids to pending ceiling raises.\n    mapping (bytes32 => Raise) public pendingRaiseMap;\n\n    /// @dev  The map of lock ids to pending seizure limit raises.\n    mapping (bytes32 => Raise) public pendingSeizureLimitRaiseMap;\n\n    // CONSTRUCTOR\n    constructor(\n        address _erc20Impl,\n        address _custodian,\n        address _limitedPrinter,\n        uint256 _initialCeiling,\n        uint256 _initialSeizureLimit\n    )\n    {\n        erc20Impl = ERC20Impl(_erc20Impl);\n        custodian = _custodian;\n        limitedPrinter = _limitedPrinter;\n        totalSupplyCeiling = _initialCeiling;\n        seizureLimit = _initialSeizureLimit;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian, \"unauthorized\");\n        _;\n    }\n    modifier onlyLimitedPrinter {\n        require(msg.sender == limitedPrinter, \"unauthorized\");\n        _;\n    }\n\n    /** @notice  Increases the token supply, with the newly created tokens\n      * being added to the balance of the specified account.\n      *\n      * @dev  The function checks that the value to print does not\n      * exceed the supply ceiling when added to the current total supply.\n      * NOTE: printing to the zero address is disallowed.\n      *\n      * @param  _receiver  The receiving address of the print.\n      * @param  _value  The number of tokens to add to the total supply and the\n      * balance of the receiving address.\n      */\n    function limitedPrint(address _receiver, uint256 _value) external onlyLimitedPrinter {\n        uint256 totalSupply = erc20Impl.totalSupply();\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follow\n            uint256 newTotalSupply = totalSupply + _value;\n            require(newTotalSupply >= totalSupply, \"overflow\");\n\n            require(newTotalSupply <= totalSupplyCeiling, \"ceiling exceeded\");\n            erc20Impl.executePrint(_receiver, _value);\n        }\n    }\n\n    function limitedBurn(address _owner, uint256 _value) external onlyLimitedPrinter {\n        require(_value <= seizureLimit, \"limit exceeded\");\n\n        unchecked {\n            // unchecked `-` is safe as `_value <= seizureLimit`\n            seizureLimit = seizureLimit - _value;\n        }\n        erc20Impl.burn(_owner, _value);\n    }\n\n    function requestRaise(mapping(bytes32 => Raise) storage _m, bytes4 _selector, uint256 _raiseBy) private returns (bytes32 lockId, uint256 lockRequestIdx) {\n        require(_raiseBy != 0, \"zero\");\n\n        (bytes32 preLockId, uint256 idx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                _selector,\n                _raiseBy\n            )\n        );\n        lockRequestIdx = idx;\n\n        _m[lockId] = Raise({\n            raiseBy: _raiseBy\n        });\n    }\n\n    /** @notice  Requests an increase to the supply ceiling.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _raiseBy  The amount by which to raise the ceiling.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCeilingRaise(uint256 _raiseBy) external returns (bytes32 lockId) {\n        (bytes32 id, uint256 idx) = requestRaise(pendingRaiseMap, this.requestCeilingRaise.selector, _raiseBy);\n\n        emit CeilingRaiseLocked(id, _raiseBy, idx);\n        return id;\n    }\n\n    /** @notice  Requests an increase to the seizure limit.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _raiseBy  The amount by which to raise the seizure limit.\n      *\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestSeizureLimitRaise(uint256 _raiseBy) external returns (bytes32 lockId) {\n        (bytes32 id, uint256 idx) = requestRaise(pendingSeizureLimitRaiseMap, this.requestSeizureLimitRaise.selector, _raiseBy);\n\n        emit SeizureLimitRaiseLocked(id, _raiseBy, idx);\n        return id;\n    }\n\n    function getRequest(mapping(bytes32 => Raise) storage _m, bytes32 _lockId) private view returns (uint256 raiseBy) {\n        Raise storage r = _m[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        raiseBy = r.raiseBy;\n        require(raiseBy != 0, \"no such lockId\");\n    }\n\n    /** @notice  Confirms a pending increase in the token supply.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending ceiling increase, the amount requested is added to the\n      * current supply ceiling.\n      * NOTE: this function will not execute any raise that would overflow the\n      * supply ceiling, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending ceiling raise request.\n      */\n    function confirmCeilingRaise(bytes32 _lockId) external onlyCustodian {\n        uint256 raiseBy = getRequest(pendingRaiseMap, _lockId);\n\n        delete pendingRaiseMap[_lockId];\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newCeiling = totalSupplyCeiling + raiseBy;\n            if (newCeiling >= totalSupplyCeiling) {\n                totalSupplyCeiling = newCeiling;\n\n                emit CeilingRaiseConfirmed(_lockId, raiseBy, newCeiling);\n            }\n        }\n    }\n\n    /** @notice  Confirms a pending increase in the seizure limit.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending seizure limit increase, the amount requested is added to the\n      * current limit.\n      * NOTE: this function will not execute any raise that would overflow the\n      * seizure limit, but it will not revert either.\n      *\n      * @param  _lockId  The identifier of a pending seizure limit raise request.\n      */\n    function confirmSeizureLimitRaise(bytes32 _lockId) external onlyCustodian {\n        uint256 raiseBy = getRequest(pendingSeizureLimitRaiseMap, _lockId);\n\n        delete pendingSeizureLimitRaiseMap[_lockId];\n\n        unchecked {\n            // unchecked `+` is safe as overflow check follows\n            uint256 newSeizureLimit = seizureLimit + raiseBy;\n            if (newSeizureLimit >= seizureLimit) {\n                seizureLimit = newSeizureLimit;\n\n                emit SeizureLimitRaiseConfirmed(_lockId, raiseBy, newSeizureLimit);\n            }\n        }\n    }\n\n    /** @notice  Lowers the supply ceiling, further constraining the bound of\n      * what can be printed by the limited printer.\n      *\n      * @dev  The limited printer is the sole authorized caller of this function,\n      * so it is the only account that can elect to lower its limit to increase\n      * the token supply.\n      *\n      * @param  _lowerBy  The amount by which to lower the supply ceiling.\n      */\n    function lowerCeiling(uint256 _lowerBy) external onlyLimitedPrinter {\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newCeiling = totalSupplyCeiling - _lowerBy;\n            require(newCeiling <= totalSupplyCeiling, \"overflow\");\n\n            totalSupplyCeiling = newCeiling;\n\n            emit CeilingLowered(_lowerBy, newCeiling);\n        }\n    }\n\n    /** @notice  Lowers the seizure limit, further constraining the bound of\n      * what can be seized (burnt) by the limited printer.\n      *\n      * @dev  The limited printer is the sole authorized caller of this function,\n      * so it is the only account that can elect to lower its limit to seize assets.\n      *\n      * @param  _lowerBy  The amount by which to lower the seizure limit.\n      */\n    function lowerSeizureLimit(uint256 _lowerBy) external onlyLimitedPrinter {\n        unchecked {\n            // unchecked `-` is safe as overflow check follows\n            uint256 newSeizureLimit = seizureLimit - _lowerBy;\n            require(newSeizureLimit <= seizureLimit, \"overflow\");\n\n            seizureLimit = newSeizureLimit;\n\n            emit SeizureLimitLowered(_lowerBy, newSeizureLimit);\n        }\n    }\n\n    /** @notice  Pass-through control of print confirmation, allowing this\n      * contract's custodian to act as the custodian of the associated\n      * active token implementation.\n      *\n      * @dev  This contract is the direct custodian of the active token\n      * implementation, but this function allows this contract's custodian\n      * to act as though it were the direct custodian of the active\n      * token implementation. Therefore the custodian retains control of\n      * unlimited printing.\n      *\n      * @param  _lockId  The identifier of a pending print request in\n      * the associated active token implementation.\n      */\n    function confirmPrintProxy(bytes32 _lockId) external onlyCustodian {\n        erc20Impl.confirmPrint(_lockId);\n    }\n\n    /** @notice  Pass-through control of custodian change confirmation,\n      * allowing this contract's custodian to act as the custodian of\n      * the associated active token implementation.\n      *\n      * @dev  This contract is the direct custodian of the active token\n      * implementation, but this function allows this contract's custodian\n      * to act as though it were the direct custodian of the active\n      * token implementation. Therefore the custodian retains control of\n      * custodian changes.\n      *\n      * @param  _lockId  The identifier of a pending custodian change request\n      * in the associated active token implementation.\n      */\n    function confirmCustodianChangeProxy(bytes32 _lockId) external onlyCustodian {\n        erc20Impl.confirmCustodianChange(_lockId);\n    }\n\n    // EVENTS\n    /// @dev  Emitted by successful `requestCeilingRaise` calls.\n    event CeilingRaiseLocked(bytes32 _lockId, uint256 _raiseBy, uint256 _lockRequestIdx);\n    /// @dev  Emitted by successful `confirmCeilingRaise` calls.\n    event CeilingRaiseConfirmed(bytes32 _lockId, uint256 _raiseBy, uint256 _newCeiling);\n\n    /// @dev  Emitted by successful `requestSeizureLimitRaise` calls.\n    event SeizureLimitRaiseLocked(bytes32 _lockId, uint256 _raiseBy, uint256 _lockRequestIdx);\n    /// @dev  Emitted by successful `confirmSeizureLimitRaise` calls.\n    event SeizureLimitRaiseConfirmed(bytes32 _lockId, uint256 _raiseBy, uint256 _newSeizureLimit);\n\n    /// @dev  Emitted by successful `lowerCeiling` calls.\n    event CeilingLowered(uint256 _lowerBy, uint256 _newCeiling);\n\n    /// @dev  Emitted by successful `lowerSeizureLimit` calls.\n    event SeizureLimitLowered(uint256 _lowerBy, uint256 _newSeizureLimit);\n}\n"},"contracts/ERC20Interface.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\ninterface ERC20Interface {\n  // METHODS\n\n  // NOTE:\n  //   public getter functions are not currently recognised as an\n  //   implementation of the matching abstract function by the compiler.\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#name\n  // function name() public view returns (string);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#symbol\n  // function symbol() public view returns (string);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply\n  // function decimals() public view returns (uint8);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#totalsupply\n  function totalSupply() external view returns (uint256);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#balanceof\n  function balanceOf(address _owner) external view returns (uint256 balance);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer\n  function transfer(address _to, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transferfrom\n  function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approve\n  function approve(address _spender, uint256 _value) external returns (bool success);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#allowance\n  function allowance(address _owner, address _spender) external view returns (uint256 remaining);\n\n  // EVENTS\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#transfer-1\n  event Transfer(address indexed _from, address indexed _to, uint256 _value);\n\n  // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md#approval\n  event Approval(address indexed _owner, address indexed _spender, uint256 _value);\n}\n"},"contracts/LockRequestable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\n/** @title  A contract for generating unique identifiers\n  *\n  * @notice  A contract that provides a identifier generation scheme,\n  * guaranteeing uniqueness across all contracts that inherit from it,\n  * as well as unpredictability of future identifiers.\n  *\n  * @dev  This contract is intended to be inherited by any contract that\n  * implements the callback software pattern for cooperative custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract LockRequestable {\n\n    // MEMBERS\n    /// @notice  the count of all invocations of `generateLockId`.\n    uint256 public lockRequestCount;\n\n    // CONSTRUCTOR\n    constructor() {\n        lockRequestCount = 0;\n    }\n\n    // FUNCTIONS\n    /** @notice  Returns a fresh unique identifier.\n      *\n      * @dev the generation scheme uses three components.\n      * First, the blockhash of the previous block.\n      * Second, the deployed address.\n      * Third, the next value of the counter.\n      * This ensure that identifiers are unique across all contracts\n      * following this scheme, and that future identifiers are\n      * unpredictable.\n      *\n      * @return lockId a 32-byte unique identifier.\n      */\n    function generateLockId() internal returns (bytes32 lockId) {\n        unchecked {\n            // unchecked `-` is safe as this can never be evaluated in the genesis (0) block\n            // unchecked `++` is safe as it is infeasible to exhaust 256-bit integer counter\n            return keccak256(\n                abi.encodePacked(\n                    blockhash(block.number - 1),\n                    address(this),\n                    ++lockRequestCount\n                )\n            );\n        }\n    }\n}\n"},"contracts/CustodianUpgradeable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./LockRequestable.sol\";\n\n/** @title  A contract to inherit upgradeable custodianship.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * custodianship. That custodian may be an account or another contract.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a custodian to control some aspect of its functionality.\n  * This contract provides the mechanism for that custodianship to be\n  * passed from one custodian to the next.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract CustodianUpgradeable is LockRequestable {\n\n    // TYPES\n    /// @dev  The struct type for pending custodian changes.\n    struct CustodianChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address public custodian;\n\n    /// @dev  The map of lock ids to pending custodian changes.\n    mapping (bytes32 => CustodianChangeRequest) public custodianChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(\n        address _custodian\n    )\n      LockRequestable()\n    {\n        custodian = _custodian;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian);\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n\n    /** @notice  Requests a change of the custodian associated with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedCustodian  The address of the new custodian.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCustodianChange(address _proposedCustodian) public returns (bytes32 lockId) {\n        require(_proposedCustodian != address(0));\n\n        lockId = generateLockId();\n\n        custodianChangeReqs[lockId] = CustodianChangeRequest({\n            proposedNew: _proposedCustodian\n        });\n\n        emit CustodianChangeRequested(lockId, msg.sender, _proposedCustodian);\n    }\n\n    /** @notice  Confirms a pending change of the custodian associated with this contract.\n      *\n      * @dev  When called by the current custodian with a lock id associated with a\n      * pending custodian change, the `address custodian` member will be updated with the\n      * requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmCustodianChange(bytes32 _lockId) public onlyCustodian {\n        custodian = getCustodianChangeReq(_lockId);\n\n        delete custodianChangeReqs[_lockId];\n\n        emit CustodianChangeConfirmed(_lockId, custodian);\n    }\n\n    // PRIVATE FUNCTIONS\n    function getCustodianChangeReq(bytes32 _lockId) private view returns (address _proposedNew) {\n        CustodianChangeRequest storage changeRequest = custodianChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0));\n\n        return changeRequest.proposedNew;\n    }\n\n    /// @dev  Emitted by successful `requestCustodianChange` calls.\n    event CustodianChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedCustodian\n    );\n\n    /// @dev Emitted by successful `confirmCustodianChange` calls.\n    event CustodianChangeConfirmed(bytes32 _lockId, address _newCustodian);\n}\n"},"contracts/ERC20ImplUpgradeable.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./CustodianUpgradeable.sol\";\nimport \"./ERC20Impl.sol\";\n\n/** @title  A contract to inherit upgradeable token implementations.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * token implementations. It itself inherits from `CustodianUpgradable`\n  * as the upgrade process is controlled by the custodian.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a reference to the active token implementation, either\n  * to delegate calls to it, or authorize calls from it. This contract\n  * provides the mechanism for that implementation to be be replaced,\n  * which constitutes an implementation upgrade.\n  *\n  * @author Gemini Trust Company, LLC\n  */\nabstract contract ERC20ImplUpgradeable is CustodianUpgradeable {\n\n    // TYPES\n    /// @dev  The struct type for pending implementation changes.\n    struct ImplChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    // @dev  The reference to the active token implementation.\n    ERC20Impl public erc20Impl;\n\n    /// @dev  The map of lock ids to pending implementation changes.\n    mapping (bytes32 => ImplChangeRequest) public implChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(address _custodian) CustodianUpgradeable(_custodian) {\n        erc20Impl = ERC20Impl(address(0));\n    }\n\n    // MODIFIERS\n    modifier onlyImpl {\n        require(msg.sender == address(erc20Impl));\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n    /** @notice  Requests a change of the active implementation associated\n      * with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedImpl  The address of the new active implementation.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestImplChange(address _proposedImpl) public returns (bytes32 lockId) {\n        require(_proposedImpl != address(0));\n\n        lockId = generateLockId();\n\n        implChangeReqs[lockId] = ImplChangeRequest({\n            proposedNew: _proposedImpl\n        });\n\n        emit ImplChangeRequested(lockId, msg.sender, _proposedImpl);\n    }\n\n    /** @notice  Confirms a pending change of the active implementation\n      * associated with this contract.\n      *\n      * @dev  When called by the custodian with a lock id associated with a\n      * pending change, the `ERC20Impl erc20Impl` member will be updated\n      * with the requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmImplChange(bytes32 _lockId) public onlyCustodian {\n        erc20Impl = getImplChangeReq(_lockId);\n\n        delete implChangeReqs[_lockId];\n\n        emit ImplChangeConfirmed(_lockId, address(erc20Impl));\n    }\n\n    // PRIVATE FUNCTIONS\n    function getImplChangeReq(bytes32 _lockId) private view returns (ERC20Impl _proposedNew) {\n        ImplChangeRequest storage changeRequest = implChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0));\n\n        return ERC20Impl(changeRequest.proposedNew);\n    }\n\n    /// @dev  Emitted by successful `requestImplChange` calls.\n    event ImplChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedImpl\n    );\n\n    /// @dev Emitted by successful `confirmImplChange` calls.\n    event ImplChangeConfirmed(bytes32 _lockId, address _newImpl);\n}\n"},"contracts/LockRequestableV1dot1.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\n/** @title  A contract for generating unique identifiers\n  *\n  * @notice  A contract that provides a identifier generation scheme,\n  * guaranteeing uniqueness across all contracts that inherit from it,\n  * as well as unpredictability of future identifiers.\n  *\n  * @dev  This contract is intended to be inherited by any contract that\n  * implements the callback software pattern for cooperative custodianship.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract LockRequestableV1dot1 {\n\n    // MEMBERS\n    /// @notice  the count of all invocations of `generatePreLockId`.\n    uint256 public lockRequestCount;\n\n    // CONSTRUCTOR\n    constructor() {\n        lockRequestCount = 0;\n    }\n\n    // FUNCTIONS\n    /** @notice  Returns a fresh unique identifier.\n      *\n      * @dev the generation scheme uses three components.\n      * First, the blockhash of the previous block.\n      * Second, the deployed address.\n      * Third, the next value of the counter.\n      * This ensure that identifiers are unique across all contracts\n      * following this scheme, and that future identifiers are\n      * unpredictable.\n      *\n      * @return preLockId a 32-byte unique identifier.\n      * @return lockRequestIdx index of lock request\n\n      */\n    function generatePreLockId() internal returns (bytes32 preLockId, uint256 lockRequestIdx) {\n        unchecked {\n            // unchecked `-` is safe as this can never be evaluated in the genesis (0) block\n            // unchecked `++` is safe as it is infeasible to exhaust 256-bit integer counter\n            lockRequestIdx = ++lockRequestCount;\n            preLockId = keccak256(\n                abi.encodePacked(\n                    blockhash(block.number - 1),\n                    address(this),\n                    lockRequestIdx\n                )\n            );\n        }\n    }\n}\n"},"contracts/CustodianUpgradeableV1dot1.sol":{"content":"// SPDX-License-Identifier: UNLICENSED\n// Copyright (c) 2020 Gemini Trust Company LLC. All Rights Reserved\npragma solidity ^0.8.0;\n\nimport \"./LockRequestableV1dot1.sol\";\n\n/** @title  A contract to inherit upgradeable custodianship.\n  *\n  * @notice  A contract that provides re-usable code for upgradeable\n  * custodianship. That custodian may be an account or another contract.\n  *\n  * @dev  This contract is intended to be inherited by any contract\n  * requiring a custodian to control some aspect of its functionality.\n  * This contract provides the mechanism for that custodianship to be\n  * passed from one custodian to the next.\n  *\n  * @author  Gemini Trust Company, LLC\n  */\nabstract contract CustodianUpgradeableV1dot1 is LockRequestableV1dot1 {\n\n    // TYPES\n    /// @dev  The struct type for pending custodian changes.\n    struct CustodianChangeRequest {\n        address proposedNew;\n    }\n\n    // MEMBERS\n    /// @dev  The address of the account or contract that acts as the custodian.\n    address public custodian;\n\n    /// @dev  The map of lock ids to pending custodian changes.\n    mapping (bytes32 => CustodianChangeRequest) public custodianChangeReqs;\n\n    // CONSTRUCTOR\n    constructor(\n        address _custodian\n    )\n      LockRequestableV1dot1()\n    {\n        custodian = _custodian;\n    }\n\n    // MODIFIERS\n    modifier onlyCustodian {\n        require(msg.sender == custodian, \"unauthorized\");\n        _;\n    }\n\n    // PUBLIC FUNCTIONS\n    // (UPGRADE)\n\n    /** @notice  Requests a change of the custodian associated with this contract.\n      *\n      * @dev  Returns a unique lock id associated with the request.\n      * Anyone can call this function, but confirming the request is authorized\n      * by the custodian.\n      *\n      * @param  _proposedCustodian  The address of the new custodian.\n      * @return  lockId  A unique identifier for this request.\n      */\n    function requestCustodianChange(address _proposedCustodian) external returns (bytes32 lockId) {\n        require(_proposedCustodian != address(0), \"zero address\");\n\n        (bytes32 preLockId, uint256 lockRequestIdx) = generatePreLockId();\n        lockId = keccak256(\n            abi.encodePacked(\n                preLockId,\n                this.requestCustodianChange.selector,\n                _proposedCustodian\n            )\n        );\n\n        custodianChangeReqs[lockId] = CustodianChangeRequest({\n            proposedNew: _proposedCustodian\n        });\n\n        emit CustodianChangeRequested(lockId, msg.sender, _proposedCustodian, lockRequestIdx);\n    }\n\n    /** @notice  Confirms a pending change of the custodian associated with this contract.\n      *\n      * @dev  When called by the current custodian with a lock id associated with a\n      * pending custodian change, the `address custodian` member will be updated with the\n      * requested address.\n      *\n      * @param  _lockId  The identifier of a pending change request.\n      */\n    function confirmCustodianChange(bytes32 _lockId) external onlyCustodian {\n        custodian = getCustodianChangeReq(_lockId);\n\n        delete custodianChangeReqs[_lockId];\n\n        emit CustodianChangeConfirmed(_lockId, custodian);\n    }\n\n    // PRIVATE FUNCTIONS\n    function getCustodianChangeReq(bytes32 _lockId) private view returns (address _proposedNew) {\n        CustodianChangeRequest storage changeRequest = custodianChangeReqs[_lockId];\n\n        // reject ‘null’ results from the map lookup\n        // this can only be the case if an unknown `_lockId` is received\n        require(changeRequest.proposedNew != address(0), \"no such lockId\");\n\n        return changeRequest.proposedNew;\n    }\n\n    /// @dev  Emitted by successful `requestCustodianChange` calls.\n    event CustodianChangeRequested(\n        bytes32 _lockId,\n        address _msgSender,\n        address _proposedCustodian,\n        uint256 _lockRequestIdx\n    );\n\n    /// @dev Emitted by successful `confirmCustodianChange` calls.\n    event CustodianChangeConfirmed(bytes32 _lockId, address _newCustodian);\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"libraries":{},"optimizer":{"runs":100000,"enabled":true},"evmVersion":"shanghai","remappings":["forge-std/=lib/forge-std/src/"]}},"stdJsonOutput":{"sources":{"contracts/ERC20Impl.sol":{"id":2},"contracts/ERC20Proxy.sol":{"id":5},"contracts/ERC20Store.sol":{"id":6},"contracts/PrintLimiter.sol":{"id":9},"contracts/ERC20Interface.sol":{"id":4},"contracts/LockRequestable.sol":{"id":7},"contracts/CustodianUpgradeable.sol":{"id":0},"contracts/ERC20ImplUpgradeable.sol":{"id":3},"contracts/LockRequestableV1dot1.sol":{"id":8},"contracts/CustodianUpgradeableV1dot1.sol":{"id":1}},"contracts":{"contracts/PrintLimiter.sol":{"PrintLimiter":{"abi":[{"type":"constructor","inputs":[{"name":"_erc20Impl","type":"address","internalType":"address"},{"name":"_custodian","type":"address","internalType":"address"},{"name":"_limitedPrinter","type":"address","internalType":"address"},{"name":"_initialCeiling","type":"uint256","internalType":"uint256"},{"name":"_initialSeizureLimit","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"CeilingLowered","type":"event","inputs":[{"name":"_lowerBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newCeiling","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CeilingRaiseConfirmed","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newCeiling","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CeilingRaiseLocked","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_lockRequestIdx","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitLowered","type":"event","inputs":[{"name":"_lowerBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newSeizureLimit","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitRaiseConfirmed","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_newSeizureLimit","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"SeizureLimitRaiseLocked","type":"event","inputs":[{"name":"_lockId","type":"bytes32","indexed":false,"internalType":"bytes32"},{"name":"_raiseBy","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"_lockRequestIdx","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"confirmCeilingRaise","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmCustodianChangeProxy","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmPrintProxy","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"confirmSeizureLimitRaise","type":"function","inputs":[{"name":"_lockId","type":"bytes32","internalType":"bytes32"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"custodian","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"erc20Impl","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"contract ERC20Impl"}],"stateMutability":"view"},{"name":"limitedBurn","type":"function","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"limitedPrint","type":"function","inputs":[{"name":"_receiver","type":"address","internalType":"address"},{"name":"_value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"limitedPrinter","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"lockRequestCount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"lowerCeiling","type":"function","inputs":[{"name":"_lowerBy","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"lowerSeizureLimit","type":"function","inputs":[{"name":"_lowerBy","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"pendingRaiseMap","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"raiseBy","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"pendingSeizureLimitRaiseMap","type":"function","inputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"raiseBy","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"requestCeilingRaise","type":"function","inputs":[{"name":"_raiseBy","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"lockId","type":"bytes32","internalType":"bytes32"}],"stateMutability":"nonpayable"},{"name":"requestSeizureLimitRaise","type":"function","inputs":[{"name":"_raiseBy","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"lockId","type":"bytes32","internalType":"bytes32"}],"stateMutability":"nonpayable"},{"name":"seizureLimit","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"totalSupplyCeiling","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"}],"metadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_erc20Impl\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_custodian\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_limitedPrinter\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_initialCeiling\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_initialSeizureLimit\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_lowerBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_newCeiling\",\"type\":\"uint256\"}],\"name\":\"CeilingLowered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_newCeiling\",\"type\":\"uint256\"}],\"name\":\"CeilingRaiseConfirmed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_lockRequestIdx\",\"type\":\"uint256\"}],\"name\":\"CeilingRaiseLocked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_lowerBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_newSeizureLimit\",\"type\":\"uint256\"}],\"name\":\"SeizureLimitLowered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_newSeizureLimit\",\"type\":\"uint256\"}],\"name\":\"SeizureLimitRaiseConfirmed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_lockRequestIdx\",\"type\":\"uint256\"}],\"name\":\"SeizureLimitRaiseLocked\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"}],\"name\":\"confirmCeilingRaise\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"}],\"name\":\"confirmCustodianChangeProxy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"}],\"name\":\"confirmPrintProxy\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"_lockId\",\"type\":\"bytes32\"}],\"name\":\"confirmSeizureLimitRaise\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"custodian\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"erc20Impl\",\"outputs\":[{\"internalType\":\"contract ERC20Impl\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"limitedBurn\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"limitedPrint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"limitedPrinter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"lockRequestCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_lowerBy\",\"type\":\"uint256\"}],\"name\":\"lowerCeiling\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_lowerBy\",\"type\":\"uint256\"}],\"name\":\"lowerSeizureLimit\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"pendingRaiseMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"raiseBy\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"name\":\"pendingSeizureLimitRaiseMap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"raiseBy\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"}],\"name\":\"requestCeilingRaise\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"lockId\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_raiseBy\",\"type\":\"uint256\"}],\"name\":\"requestSeizureLimitRaise\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"lockId\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"seizureLimit\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupplyCeiling\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Gemini Trust Company, LLC\",\"details\":\"This contract is a layer of indirection between an instance of ERC20Impl and a custodian. The functionality of the custodianship over the token implementation is preserved (printing and custodian changes), but this contract adds the ability for an additional key (the 'limited printer') to increase the token supply up to a ceiling, and this supply ceiling can only be raised by the custodian.\",\"events\":{\"CeilingLowered(uint256,uint256)\":{\"details\":\"Emitted by successful `lowerCeiling` calls.\"},\"CeilingRaiseConfirmed(bytes32,uint256,uint256)\":{\"details\":\"Emitted by successful `confirmCeilingRaise` calls.\"},\"CeilingRaiseLocked(bytes32,uint256,uint256)\":{\"details\":\"Emitted by successful `requestCeilingRaise` calls.\"},\"SeizureLimitLowered(uint256,uint256)\":{\"details\":\"Emitted by successful `lowerSeizureLimit` calls.\"},\"SeizureLimitRaiseConfirmed(bytes32,uint256,uint256)\":{\"details\":\"Emitted by successful `confirmSeizureLimitRaise` calls.\"},\"SeizureLimitRaiseLocked(bytes32,uint256,uint256)\":{\"details\":\"Emitted by successful `requestSeizureLimitRaise` calls.\"}},\"kind\":\"dev\",\"methods\":{\"confirmCeilingRaise(bytes32)\":{\"details\":\"When called by the custodian with a lock id associated with a pending ceiling increase, the amount requested is added to the current supply ceiling. NOTE: this function will not execute any raise that would overflow the supply ceiling, but it will not revert either.\",\"params\":{\"_lockId\":\"The identifier of a pending ceiling raise request.\"}},\"confirmCustodianChangeProxy(bytes32)\":{\"details\":\"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of custodian changes.\",\"params\":{\"_lockId\":\"The identifier of a pending custodian change request in the associated active token implementation.\"}},\"confirmPrintProxy(bytes32)\":{\"details\":\"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of unlimited printing.\",\"params\":{\"_lockId\":\"The identifier of a pending print request in the associated active token implementation.\"}},\"confirmSeizureLimitRaise(bytes32)\":{\"details\":\"When called by the custodian with a lock id associated with a pending seizure limit increase, the amount requested is added to the current limit. NOTE: this function will not execute any raise that would overflow the seizure limit, but it will not revert either.\",\"params\":{\"_lockId\":\"The identifier of a pending seizure limit raise request.\"}},\"limitedPrint(address,uint256)\":{\"details\":\"The function checks that the value to print does not exceed the supply ceiling when added to the current total supply. NOTE: printing to the zero address is disallowed.\",\"params\":{\"_receiver\":\"The receiving address of the print.\",\"_value\":\"The number of tokens to add to the total supply and the balance of the receiving address.\"}},\"lowerCeiling(uint256)\":{\"details\":\"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to increase the token supply.\",\"params\":{\"_lowerBy\":\"The amount by which to lower the supply ceiling.\"}},\"lowerSeizureLimit(uint256)\":{\"details\":\"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to seize assets.\",\"params\":{\"_lowerBy\":\"The amount by which to lower the seizure limit.\"}},\"requestCeilingRaise(uint256)\":{\"details\":\"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.\",\"params\":{\"_raiseBy\":\"The amount by which to raise the ceiling.\"},\"returns\":{\"lockId\":\" A unique identifier for this request.\"}},\"requestSeizureLimitRaise(uint256)\":{\"details\":\"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.\",\"params\":{\"_raiseBy\":\"The amount by which to raise the seizure limit.\"},\"returns\":{\"lockId\":\" A unique identifier for this request.\"}}},\"stateVariables\":{\"custodian\":{\"details\":\"The address of the account or contract that acts as the custodian.\"},\"erc20Impl\":{\"details\":\"The reference to the active token implementation.\"},\"limitedPrinter\":{\"details\":\"The sole authorized caller of limited printing. This account is also authorized to lower the supply ceiling.\"},\"pendingRaiseMap\":{\"details\":\"The map of lock ids to pending ceiling raises.\"},\"pendingSeizureLimitRaiseMap\":{\"details\":\"The map of lock ids to pending seizure limit raises.\"},\"seizureLimit\":{\"details\":\"The maximum that can be seized (burnt) through use of the limited burn feature. The value of the limit can only be increased by the custodian. The value of the limit can be decreased by the 'limited printer'.\"},\"totalSupplyCeiling\":{\"details\":\"The maximum that the token supply can be increased to through use of the limited printing feature. The difference between the current total supply and the supply ceiling is what is available to the 'limited printer' account. The value of the ceiling can only be increased by the custodian.\"}},\"title\":\"A contact to govern hybrid control over increases to the token supply.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"confirmCeilingRaise(bytes32)\":{\"notice\":\"Confirms a pending increase in the token supply.\"},\"confirmCustodianChangeProxy(bytes32)\":{\"notice\":\"Pass-through control of custodian change confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation.\"},\"confirmPrintProxy(bytes32)\":{\"notice\":\"Pass-through control of print confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation.\"},\"confirmSeizureLimitRaise(bytes32)\":{\"notice\":\"Confirms a pending increase in the seizure limit.\"},\"limitedPrint(address,uint256)\":{\"notice\":\"Increases the token supply, with the newly created tokens being added to the balance of the specified account.\"},\"lockRequestCount()\":{\"notice\":\"the count of all invocations of `generatePreLockId`.\"},\"lowerCeiling(uint256)\":{\"notice\":\"Lowers the supply ceiling, further constraining the bound of what can be printed by the limited printer.\"},\"lowerSeizureLimit(uint256)\":{\"notice\":\"Lowers the seizure limit, further constraining the bound of what can be seized (burnt) by the limited printer.\"},\"requestCeilingRaise(uint256)\":{\"notice\":\"Requests an increase to the supply ceiling.\"},\"requestSeizureLimitRaise(uint256)\":{\"notice\":\"Requests an increase to the seizure limit.\"}},\"notice\":\"A contract that acts as a custodian of the active token implementation, and an intermediary between it and the ‘true’ custodian. It preserves the functionality of direct custodianship as well as granting limited control of token supply increases to an additional key.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/PrintLimiter.sol\":\"PrintLimiter\"},\"evmVersion\":\"shanghai\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000},\"remappings\":[\":forge-std/=lib/forge-std/src/\"]},\"sources\":{\"contracts/CustodianUpgradeable.sol\":{\"keccak256\":\"0xec12d8a933801a5540d1d3f33014a2674fce159ac5c5c293ae456118b2a6ffe9\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://5c22e1bd87d78b4d13ab1be01e6006a5bebf20e300db2eac38370c05b3781c43\",\"dweb:/ipfs/QmUaxjk3LVA6UDXbycG2aYAQyYBKKTvQpuusp9QeCe3pME\"]},\"contracts/CustodianUpgradeableV1dot1.sol\":{\"keccak256\":\"0xe4d4a08714522c58f750ee4a5b1fe599169d248afba89f135801d9663d07ced5\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://71eeee97fd0492b19cf6a339b305ccda77fc48f823e7f7f0de8ed3c1b5e28963\",\"dweb:/ipfs/QmRmE3LEZ82GHqdSgG49PomFsbqYpeg8o8cyfLAHS8gJea\"]},\"contracts/ERC20Impl.sol\":{\"keccak256\":\"0x28994b983f9cc476de866c39ac9e71e69373dd88e3a764e55afdb26c600332ce\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://acb53286dba2b61976d4908e9176a0c6532a5537eda616576369efe7a8cbed62\",\"dweb:/ipfs/QmYESzkaeb76AU9hktrVSFk2yzKvHuYJsJnYjw7QY8LmN3\"]},\"contracts/ERC20ImplUpgradeable.sol\":{\"keccak256\":\"0x5de6ecbc2eb9188e4541dc4659ee2c389e9f855e26d896976a5d7bdbb546a9e9\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://a99ca65203b7366e5089484b37107d3585c5915d21b1c807c1825efe63a12786\",\"dweb:/ipfs/QmeShSCPMCLAKznCAnAAt5gBfvKxFWsWacKbZrx7vu9sZn\"]},\"contracts/ERC20Interface.sol\":{\"keccak256\":\"0x7872d028ae35e1adf3ca57e032888254983dce8c7df276b5a6f5cc8476cb0969\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://7420c36a5b5665d86c98ebecc2e1410705f662ab770a4c3316bb5b9aac966f18\",\"dweb:/ipfs/QmaZ4k1rbm9LG2tj2bU7JHzFXUxu3yHAot567o8pa4FgTK\"]},\"contracts/ERC20Proxy.sol\":{\"keccak256\":\"0xc25caf6187f951f721f8958b380e211b4beab56d08febbcd71711c7dee20d450\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://859e8c7f14b37bb0143190e12889e3cc74517188b6f277dd4e740885e0ef3dc5\",\"dweb:/ipfs/QmeU29JrHpqzNzEBpiL8JMBoLAy4DizcGX7V8EVnm14Hxh\"]},\"contracts/ERC20Store.sol\":{\"keccak256\":\"0x9d3aff9e93cb489be4b061793224d929db7900390d4d88831cd0f4f8cb11fb09\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://6ae632cabb50b1437db3628433d5bdffb20edd4cad15ab80df259235ba60b8c9\",\"dweb:/ipfs/QmYjoZZVdioMW1F127QoGW4cBJ1oTAkvQ8YvzkJkxeZun8\"]},\"contracts/LockRequestable.sol\":{\"keccak256\":\"0x7cbb420ccffa171a9db6557c0c21629968df1b90f11d9aedf9fdb50f1f777a1d\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://f23127f71d75faea6ed8251019b958d0a3aac311a01b030659acac1520b4b1d8\",\"dweb:/ipfs/QmW4Xay821UHHLhosMJx6QrZ3bRssBVdB5Enoy5444ZiLY\"]},\"contracts/LockRequestableV1dot1.sol\":{\"keccak256\":\"0x5ae098cedf263ee5a0e55f03b9c9cd15cf6fd5b75e42dfcf83928c6c50f6e43f\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://c57bba880e1cc1469af929c698c5fe793f37270ec6e7782c953a31fa06eb4f33\",\"dweb:/ipfs/QmfXBxRAA83nRpyoDWqx1a94aKRTy7YZS4MJBX7beHH6jd\"]},\"contracts/PrintLimiter.sol\":{\"keccak256\":\"0x1ac5aa634b534a7ebf8bd7976b2585090e29b292eb336a9780612121ab07b371\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://5ab43057ebf2b341482803da6bd7026835a5903d8b696483fe0625f24e0d6dcc\",\"dweb:/ipfs/QmZNNBVcYhScyKKBJnct1v7zr7JVkyzmpPu6kU2nCriqAL\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"A contract that acts as a custodian of the active token implementation, and an intermediary between it and the ‘true’ custodian. It preserves the functionality of direct custodianship as well as granting limited control of token supply increases to an additional key.","methods":{"lockRequestCount()":{"notice":"the count of all invocations of `generatePreLockId`."},"lowerCeiling(uint256)":{"notice":"Lowers the supply ceiling, further constraining the bound of what can be printed by the limited printer."},"confirmPrintProxy(bytes32)":{"notice":"Pass-through control of print confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."},"lowerSeizureLimit(uint256)":{"notice":"Lowers the seizure limit, further constraining the bound of what can be seized (burnt) by the limited printer."},"confirmCeilingRaise(bytes32)":{"notice":"Confirms a pending increase in the token supply."},"requestCeilingRaise(uint256)":{"notice":"Requests an increase to the supply ceiling."},"limitedPrint(address,uint256)":{"notice":"Increases the token supply, with the newly created tokens being added to the balance of the specified account."},"confirmSeizureLimitRaise(bytes32)":{"notice":"Confirms a pending increase in the seizure limit."},"requestSeizureLimitRaise(uint256)":{"notice":"Requests an increase to the seizure limit."},"confirmCustodianChangeProxy(bytes32)":{"notice":"Pass-through control of custodian change confirmation, allowing this contract's custodian to act as the custodian of the associated active token implementation."}},"version":1},"devdoc":{"kind":"dev","title":"A contact to govern hybrid control over increases to the token supply.","author":"Gemini Trust Company, LLC","events":{"CeilingLowered(uint256,uint256)":{"details":"Emitted by successful `lowerCeiling` calls."},"SeizureLimitLowered(uint256,uint256)":{"details":"Emitted by successful `lowerSeizureLimit` calls."},"CeilingRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestCeilingRaise` calls."},"CeilingRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmCeilingRaise` calls."},"SeizureLimitRaiseLocked(bytes32,uint256,uint256)":{"details":"Emitted by successful `requestSeizureLimitRaise` calls."},"SeizureLimitRaiseConfirmed(bytes32,uint256,uint256)":{"details":"Emitted by successful `confirmSeizureLimitRaise` calls."}},"details":"This contract is a layer of indirection between an instance of ERC20Impl and a custodian. The functionality of the custodianship over the token implementation is preserved (printing and custodian changes), but this contract adds the ability for an additional key (the 'limited printer') to increase the token supply up to a ceiling, and this supply ceiling can only be raised by the custodian.","methods":{"lowerCeiling(uint256)":{"params":{"_lowerBy":"The amount by which to lower the supply ceiling."},"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to increase the token supply."},"confirmPrintProxy(bytes32)":{"params":{"_lockId":"The identifier of a pending print request in the associated active token implementation."},"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of unlimited printing."},"lowerSeizureLimit(uint256)":{"params":{"_lowerBy":"The amount by which to lower the seizure limit."},"details":"The limited printer is the sole authorized caller of this function, so it is the only account that can elect to lower its limit to seize assets."},"confirmCeilingRaise(bytes32)":{"params":{"_lockId":"The identifier of a pending ceiling raise request."},"details":"When called by the custodian with a lock id associated with a pending ceiling increase, the amount requested is added to the current supply ceiling. NOTE: this function will not execute any raise that would overflow the supply ceiling, but it will not revert either."},"requestCeilingRaise(uint256)":{"params":{"_raiseBy":"The amount by which to raise the ceiling."},"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","returns":{"lockId":" A unique identifier for this request."}},"limitedPrint(address,uint256)":{"params":{"_value":"The number of tokens to add to the total supply and the balance of the receiving address.","_receiver":"The receiving address of the print."},"details":"The function checks that the value to print does not exceed the supply ceiling when added to the current total supply. NOTE: printing to the zero address is disallowed."},"confirmSeizureLimitRaise(bytes32)":{"params":{"_lockId":"The identifier of a pending seizure limit raise request."},"details":"When called by the custodian with a lock id associated with a pending seizure limit increase, the amount requested is added to the current limit. NOTE: this function will not execute any raise that would overflow the seizure limit, but it will not revert either."},"requestSeizureLimitRaise(uint256)":{"params":{"_raiseBy":"The amount by which to raise the seizure limit."},"details":"Returns a unique lock id associated with the request. Anyone can call this function, but confirming the request is authorized by the custodian.","returns":{"lockId":" A unique identifier for this request."}},"confirmCustodianChangeProxy(bytes32)":{"params":{"_lockId":"The identifier of a pending custodian change request in the associated active token implementation."},"details":"This contract is the direct custodian of the active token implementation, but this function allows this contract's custodian to act as though it were the direct custodian of the active token implementation. Therefore the custodian retains control of custodian changes."}},"version":1,"stateVariables":{"custodian":{"details":"The address of the account or contract that acts as the custodian."},"erc20Impl":{"details":"The reference to the active token implementation."},"seizureLimit":{"details":"The maximum that can be seized (burnt) through use of the limited burn feature. The value of the limit can only be increased by the custodian. The value of the limit can be decreased by the 'limited printer'."},"limitedPrinter":{"details":"The sole authorized caller of limited printing. This account is also authorized to lower the supply ceiling."},"pendingRaiseMap":{"details":"The map of lock ids to pending ceiling raises."},"totalSupplyCeiling":{"details":"The maximum that the token supply can be increased to through use of the limited printing feature. The difference between the current total supply and the supply ceiling is what is available to the 'limited printer' account. The value of the ceiling can only be increased by the custodian."},"pendingSeizureLimitRaiseMap":{"details":"The map of lock ids to pending seizure limit raises."}}},"storageLayout":{"types":{"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_struct(Raise)1848_storage":{"label":"struct PrintLimiter.Raise","members":[{"slot":"0","type":"t_uint256","astId":1847,"label":"raiseBy","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"}],"encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(Raise)1848_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct PrintLimiter.Raise)","value":"t_struct(Raise)1848_storage","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":1794,"label":"lockRequestCount","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"1","type":"t_uint256","astId":1861,"label":"totalSupplyCeiling","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"2","type":"t_uint256","astId":1864,"label":"seizureLimit","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"3","type":"t_mapping(t_bytes32,t_struct(Raise)1848_storage)","astId":1870,"label":"pendingRaiseMap","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"},{"slot":"4","type":"t_mapping(t_bytes32,t_struct(Raise)1848_storage)","astId":1876,"label":"pendingSeizureLimitRaiseMap","offset":0,"contract":"contracts/PrintLimiter.sol:PrintLimiter"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"1057:12080:9:-:0;;;2606:397;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;822:1:8;803:20;;-1:-1:-1;;;;;2798:33:9;;;;;2841:22;;;;;2873:32;;;;2915:18;:36;;;;2961:12;:35;1057:12080;;14:177:10;93:13;;-1:-1:-1;;;;;135:31:10;;125:42;;115:70;;181:1;178;171:12;115:70;14:177;;;:::o;196:600::-;302:6;310;318;326;334;387:3;375:9;366:7;362:23;358:33;355:53;;;404:1;401;394:12;355:53;427:40;457:9;427:40;:::i;:::-;417:50;;486:49;531:2;520:9;516:18;486:49;:::i;:::-;476:59;;554:49;599:2;588:9;584:18;554:49;:::i;:::-;665:2;650:18;;644:25;759:3;744:19;;;738:26;196:600;;;;-1:-1:-1;544:59:10;644:25;738:26;196:600;-1:-1:-1;;;196:600:10:o;:::-;1057:12080:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1057:12080:9:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12078:135;;;;;;:::i;:::-;;:::i;:::-;;7409:529;;;;;;:::i;:::-;;:::i;2396:49::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;345:25:10;;;333:2;318:18;2396:49:9;;;;;;;;9416:401;;;;;;:::i;:::-;;:::i;1433:34::-;;;;;;;;788:42:10;776:55;;;758:74;;746:2;731:18;1433:34:9;612:226:10;10225:413:9;;;;;;:::i;:::-;;:::i;1309:36::-;;;;;4294:333;;;;;;:::i;:::-;;:::i;1614:39::-;;;;;2519:61;;;;;;:::i;:::-;;;;;;;;;;;;;;2301:27;;;;;;11290:115;;;;;;:::i;:::-;;:::i;2005:33::-;;;;;;3790:498;;;;;;:::i;:::-;;:::i;8427:565::-;;;;;;:::i;:::-;;:::i;5567:272::-;;;;;;:::i;:::-;;:::i;722:31:8:-;;;;;;6249:299:9;;;;;;:::i;:::-;;:::i;12078:135::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;;;;;;;;;12165:41:::1;::::0;;;;::::1;::::0;::::1;345:25:10::0;;;12165:9:9::1;:32;;::::0;::::1;::::0;318:18:10;;12165:41:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12078:135:::0;:::o;7409:529::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;7488:15:::1;7506:36;7517:15;7534:7;7506:10;:36::i;:::-;7560:24;::::0;;;:15:::1;:24;::::0;;;;7553:31;7703:18:::1;::::0;7488:54;;-1:-1:-1;7703:28:9;;::::1;::::0;7749:32;::::1;7745:177;;7801:18;:31:::0;;;7856:51:::1;::::0;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;7856:51:9::1;::::0;2239:2:10;2224:18;7856:51:9::1;;;;;;;;7745:177;7595:337;7478:460;7409:529:::0;:::o;9416:401::-;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;9602:18:::1;::::0;:29;;::::1;::::0;9653:32;::::1;;9645:53;;;::::0;::::1;::::0;;2575:2:10;9645:53:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;9645:53:9::1;2373:331:10::0;9645:53:9::1;9713:18;:31:::0;;;9764:36:::1;::::0;;2883:25:10;;;2939:2;2924:18;;2917:34;;;9764:36:9::1;::::0;2856:18:10;9764:36:9::1;;;;;;;;9494:317;9416:401:::0;:::o;10225:413::-;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;10421:12:::1;::::0;:23;;::::1;::::0;10466:31;::::1;;10458:52;;;::::0;::::1;::::0;;2575:2:10;10458:52:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;10458:52:9::1;2373:331:10::0;10458:52:9::1;10525:12;:30:::0;;;10575:46:::1;::::0;;2883:25:10;;;2939:2;2924:18;;2917:34;;;10575:46:9::1;::::0;2856:18:10;10575:46:9::1;2709:248:10::0;4294:333:9;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;4403:12:::1;;4393:6;:22;;4385:49;;;::::0;::::1;::::0;;3164:2:10;4385:49:9::1;::::0;::::1;3146:21:10::0;3203:2;3183:18;;;3176:30;3242:16;3222:18;;;3215:44;3276:18;;4385:49:9::1;2962:338:10::0;4385:49:9::1;4549:12;::::0;;:21;;::::1;4534:36:::0;;4590:30:::1;::::0;;;;:14:::1;3497:55:10::0;;;4590:30:9::1;::::0;::::1;3479:74:10::0;3569:18;;;3562:34;;;4590:9:9::1;:14;::::0;::::1;::::0;3452:18:10;;4590:30:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4294:333:::0;;:::o;11290:115::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;11367:31:::1;::::0;;;;::::1;::::0;::::1;345:25:10::0;;;11367:9:9::1;:22;;::::0;::::1;::::0;318:18:10;;11367:31:9::1;199:177:10::0;3790:498:9;3176:10;:28;3190:14;3176:28;;3168:53;;;;;;;1910:2:10;3168:53:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3168:53:9;1708:336:10;3168:53:9;3885:19:::1;3907:9;:21;;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3885:45:::0;-1:-1:-1;4052:20:9;;::::1;4094:29:::0;;::::1;;4086:50;;;::::0;::::1;::::0;;2575:2:10;4086:50:9::1;::::0;::::1;2557:21:10::0;2614:1;2594:18;;;2587:29;2652:10;2632:18;;;2625:38;2680:18;;4086:50:9::1;2373:331:10::0;4086:50:9::1;4177:18;;4159:14;:36;;4151:65;;;::::0;::::1;::::0;;3998:2:10;4151:65:9::1;::::0;::::1;3980:21:10::0;4037:2;4017:18;;;4010:30;4076:18;4056;;;4049:46;4112:18;;4151:65:9::1;3796:340:10::0;4151:65:9::1;4230:41;::::0;;;;:22:::1;3497:55:10::0;;;4230:41:9::1;::::0;::::1;3479:74:10::0;3569:18;;;3562:34;;;4230:9:9::1;:22;::::0;::::1;::::0;3452:18:10;;4230:41:9::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3941:341;3875:413;3790:498:::0;;:::o;8427:565::-;3067:10;:23;3081:9;3067:23;;3059:48;;;;;;;1910:2:10;3059:48:9;;;1892:21:10;1949:2;1929:18;;;1922:30;1988:14;1968:18;;;1961:42;2020:18;;3059:48:9;1708:336:10;3059:48:9;8511:15:::1;8529:48;8540:27;8569:7;8529:10;:48::i;:::-;8595:36;::::0;;;:27:::1;:36;::::0;;;;8588:43;8755:12:::1;::::0;8511:66;;-1:-1:-1;8755:22:9;;::::1;::::0;8795:31;::::1;8791:185;;8846:12;:30:::0;;;8900:61:::1;::::0;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;8900:61:9::1;::::0;2239:2:10;2224:18;8900:61:9::1;2049:319:10::0;5567:272:9;5632:14;;;5686:74;5699:15;5716:33;5751:8;5686:12;:74::i;:::-;5776:37;;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;5658:102:9;;-1:-1:-1;5658:102:9;-1:-1:-1;5776:37:9;;2239:2:10;2224:18;5776:37:9;;;;;;;;-1:-1:-1;5830:2:9;5567:272;-1:-1:-1;;5567:272:9:o;6249:299::-;6319:14;;;6373:91;6386:27;6415:38;6455:8;6373:12;:91::i;:::-;6480:42;;;2251:25:10;;;2307:2;2292:18;;2285:34;;;2335:18;;;2328:34;;;6345:119:9;;-1:-1:-1;6345:119:9;-1:-1:-1;6480:42:9;;2239:2:10;2224:18;6480:42:9;2049:319:10;6554:369:9;6651:15;6696:11;;;;;;;;;;6858:9;;;6885:12;;;6877:39;;;;;;;4343:2:10;6877:39:9;;;4325:21:10;4382:2;4362:18;;;4355:30;4421:16;4401:18;;;4394:44;4455:18;;6877:39:9;4141:338:10;6877:39:9;6668:255;6554:369;;;;:::o;4633:529::-;4746:14;4762:22;4804:8;4816:1;4804:13;4796:30;;;;;;;;;;;4686:2:10;4668:21;;;4725:1;4705:18;;;4698:29;4763:6;4758:2;4743:18;;4736:34;4802:2;4787:18;;4484:327;4796:30:9;4838:17;4857:11;4872:19;1435:17:8;1715:18;;;;;;;1786:154;;;1834:12;:16;;1824:27;1786:154;;;5389:19:10;5459:66;1881:4:8;5446:2:10;5442:15;5438:88;5424:12;;;5417:110;;;;5543:12;;;5536:28;;;5580:12;;1786:154:8;;;;;;;;;;;;1759:195;;;;;;1747:207;;1388:583;;;4872:19:9;4933:110;;;;;;4999:19:10;;;5060:66;5048:79;;5034:12;;;5027:101;;;;5144:12;;;5137:28;;;4837:54:9;;-1:-1:-1;4837:54:9;-1:-1:-1;5181:12:10;;4933:110:9;;;;;;;;;;;;;4910:143;;4933:110;4910:143;;;;5107:48;;;;;;;;-1:-1:-1;5094:10:9;;;;;;;;;:61;;;;;-1:-1:-1;4910:143:9;;4633:529;-1:-1:-1;;;4633:529:9:o;14:180:10:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:10;;14:180;-1:-1:-1;14:180:10:o;1092:429::-;1160:6;1168;1221:2;1209:9;1200:7;1196:23;1192:32;1189:52;;;1237:1;1234;1227:12;1189:52;1276:9;1263:23;1326:42;1319:5;1315:54;1308:5;1305:65;1295:93;;1384:1;1381;1374:12;1295:93;1407:5;1485:2;1470:18;;;;1457:32;;-1:-1:-1;;;1092:429:10:o;3607:184::-;3677:6;3730:2;3718:9;3709:7;3705:23;3701:32;3698:52;;;3746:1;3743;3736:12;3698:52;-1:-1:-1;3769:16:10;;3607:184;-1:-1:-1;3607:184:10:o","linkReferences":{},"immutableReferences":{"1852":[{"start":516,"length":32},{"start":971,"length":32},{"start":2381,"length":32},{"start":2678,"length":32},{"start":2908,"length":32},{"start":3342,"length":32}],"1855":[{"start":421,"length":32},{"start":784,"length":32},{"start":1107,"length":32},{"start":2496,"length":32},{"start":3459,"length":32}],"1858":[{"start":574,"length":32},{"start":1385,"length":32},{"start":1723,"length":32},{"start":2053,"length":32},{"start":2770,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"confirmCeilingRaise(bytes32)","signatureHash4":"0x12460fdd","signatureHash32":"0x12460fdda9de06502350db9f755439c03aaf9438e9fa13261fe29721f4265d61"},{"signature":"confirmCustodianChangeProxy(bytes32)","signatureHash4":"0x051d9955","signatureHash32":"0x051d99559a992f5590a25b0e94d59eaf7500b73c774c482d1a34b77212ee1d5c"},{"signature":"confirmPrintProxy(bytes32)","signatureHash4":"0x8cbf4145","signatureHash32":"0x8cbf414596c5ded2944e0a1a5a112c2f34c12fc6d5675c2ebbd1c503c4ed9d5c"},{"signature":"confirmSeizureLimitRaise(bytes32)","signatureHash4":"0xba157d85","signatureHash32":"0xba157d85c1b65fa3eb4d01bf6441aafed7ace456963eaaa84369378967740f88"},{"signature":"custodian()","signatureHash4":"0x375b74c3","signatureHash32":"0x375b74c3f9e6246b0454041156e7125eb7cfa37a6deb0b0f1f786d7b5401aacd"},{"signature":"erc20Impl()","signatureHash4":"0x3c389cc4","signatureHash32":"0x3c389cc4934f243bdd297e062845ca7dacd39b4666efa0b2500de1e9f8986993"},{"signature":"limitedBurn(address,uint256)","signatureHash4":"0x413b111a","signatureHash32":"0x413b111a55cb61956645cfd242fa7efbebcee381a74acd2ce9705e93b79c5b4c"},{"signature":"limitedPrint(address,uint256)","signatureHash4":"0xa94c7c65","signatureHash32":"0xa94c7c656ca6d7701fb5bd9b561bf39187d5d1b7fc965337600a07286e511fca"},{"signature":"limitedPrinter()","signatureHash4":"0x42569ff3","signatureHash32":"0x42569ff3c7e2cd272474c712371f6ee2a0016e4411695a46922c78c305852072"},{"signature":"lockRequestCount()","signatureHash4":"0xcb81fecf","signatureHash32":"0xcb81fecfd378503e5338a7ce5804b9b9a2b9c256ea30ec8a8e3a71dbb715639c"},{"signature":"lowerCeiling(uint256)","signatureHash4":"0x33513739","signatureHash32":"0x335137392f318250dea2f128021b6656b18e5046078ba7539e7e413e666359b4"},{"signature":"lowerSeizureLimit(uint256)","signatureHash4":"0x3835a26e","signatureHash32":"0x3835a26e1d2dda3aa185f9767a5a8485bfa383872f757f11d62667bc777efe0c"},{"signature":"pendingRaiseMap(bytes32)","signatureHash4":"0x264da19e","signatureHash32":"0x264da19e4dfcde337093dfd5a7b7e5079f8a7f6c2a44b261b2f0b7f5bf4355d4"},{"signature":"pendingSeizureLimitRaiseMap(bytes32)","signatureHash4":"0x47cdbad8","signatureHash32":"0x47cdbad80cff92218aa8d686d4b7c58db94bb52a5b868c6acbfb813ef607045d"},{"signature":"requestCeilingRaise(uint256)","signatureHash4":"0xc9bc5dbd","signatureHash32":"0xc9bc5dbd9015a16573673480c139196d8c8ba52a7fe0f42ae303079b61335d22"},{"signature":"requestSeizureLimitRaise(uint256)","signatureHash4":"0xdd79c59c","signatureHash32":"0xdd79c59c1a939b2cd89f2199d626563fe323dbd8be4f8c2e36dedaa01ab350a2"},{"signature":"seizureLimit()","signatureHash4":"0x7c244f7f","signatureHash32":"0x7c244f7fadf7736ef89ea498ec60c38c4b1e6390a877c455f390557a4b6e9a94"},{"signature":"totalSupplyCeiling()","signatureHash4":"0x95a51233","signatureHash32":"0x95a5123345793d09db059b8b1efd41c4e17ebb6cc2fe3faab93fd9cf003ff8f0"}],"event":[{"signature":"CeilingLowered(uint256,uint256)","signatureHash4":"0x76f283ae","signatureHash32":"0x76f283ae36a7f1bcca5e9475a544804430c59279a8b72325d56fb5ade52ab632"},{"signature":"CeilingRaiseConfirmed(bytes32,uint256,uint256)","signatureHash4":"0x3779579f","signatureHash32":"0x3779579f908c94480802e9c026789736b5c6a0382577c15f94feb7e23eafcfd2"},{"signature":"CeilingRaiseLocked(bytes32,uint256,uint256)","signatureHash4":"0x0fa9af5c","signatureHash32":"0x0fa9af5c2d5a53fc8373c91c802bd6ddacc08ad835c830c551636233fcd2a803"},{"signature":"SeizureLimitLowered(uint256,uint256)","signatureHash4":"0x59faf806","signatureHash32":"0x59faf806415014d769a16a47b9f063a880bcb3e9f93d813968a776685e790834"},{"signature":"SeizureLimitRaiseConfirmed(bytes32,uint256,uint256)","signatureHash4":"0x00ce8231","signatureHash32":"0x00ce8231d6afabbd4d6638aa83e30b88cd477affe08656de90ad2ceb8301633d"},{"signature":"SeizureLimitRaiseLocked(bytes32,uint256,uint256)","signatureHash4":"0xe5a28859","signatureHash32":"0xe5a28859e6a2be63fd9a1ad5f60f3f54f247aaa2db3f24d9a64ca5a7aa5a49de"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x342c1B88c2108f159a4Ef37e322B4170b18C42f6"}