{"matchId":"28328089","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-04-27T02:32:40Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1086:1098:0:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c13ac720138025f0b3ab0b6066d52bf02f2c75efbd237e3647772e15705249a364736f6c63430008110033","offset":1547}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1086:1098:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1163:130;;;;;;:::i;:::-;;:::i;:::-;;;1258:28;1267:2;1271:4;1277:8;1258;:28::i;:::-;1163:130;;;:::o;1436:746::-;1523:17;1542:15;1572:8;1561:40;;;;;;;;;;;;:::i;:::-;1522:79;;;;1612:18;1640:9;-1:-1:-1;;;;;1633:27:0;;1669:4;1633:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1612:63;;1706:1;1693:10;:14;1685:57;;;;-1:-1:-1;;;1685:57:0;;2611:2:8;1685:57:0;;;2593:21:8;2650:2;2630:18;;;2623:30;2689:32;2669:18;;;2662:60;2739:18;;1685:57:0;;;;;;;;1753:48;-1:-1:-1;;;;;1753:30:0;;1784:4;1790:10;1753:30;:48::i;:::-;1969:76;;-1:-1:-1;;;1969:76:0;;-1:-1:-1;;;;;3091:15:8;;;1969:76:0;;;3073:34:8;3143:15;;;3123:18;;;3116:43;3175:18;;;3168:34;;;2039:1:0;3218:18:8;;;3211:34;3282:15;;;3261:19;;;3254:44;1969:37:0;;;;;3007:19:8;;1969:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1969:76:0;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2098:39:0;-1:-1:-1;;;;;2098:30:0;;2129:4;2135:1;2098:30;:39::i;:::-;2148:27;2165:9;2148:16;:27::i;:::-;1512:670;;;1436:746;;;:::o;1646:410:7:-;1738:56;1748:5;-1:-1:-1;;;1779:7:7;1788:5;1738:9;:56::i;:::-;1733:317;;1832:52;1842:5;-1:-1:-1;;;1873:7:7;1882:1;1832:9;:52::i;:::-;1831:53;:134;;;-1:-1:-1;1909:56:7;1919:5;-1:-1:-1;;;1950:7:7;1959:5;1909:9;:56::i;:::-;1908:57;1831:134;1810:230;;;2005:20;;-1:-1:-1;;;2005:20:7;;;;;;;;;;;972:310:5;1022:19;1044:16;:14;:16::i;:::-;1022:38;-1:-1:-1;;;;;;1074:25:5;;1070:38;;1101:7;972:310;:::o;1070:38::-;1133;;-1:-1:-1;;;1133:38:5;;1118:12;;-1:-1:-1;;;;;1133:23:5;;;;;:38;;1165:4;;1133:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1118:53;-1:-1:-1;1185:8:5;;1181:95;;1209:56;1239:5;1247:11;1260:4;1209:22;:56::i;3155:696:7:-;3250:12;3413:4;3407:11;3445:8;3439:4;3432:22;3491:2;3484:4;3478;3474:15;3467:27;3531:6;3524:4;3518;3514:15;3507:31;3601:4;3596:3;3590:4;3584;3581:1;3574:5;3567;3562:44;3551:55;;;3622:7;3619:216;;;3655:16;3688:47;;;;3816:1;3812;3806:8;3803:15;3798:2;3780:16;3777:24;3773:46;3762:57;;3648:173;;3688:47;3731:1;3723:5;3711:18;3708:25;3697:36;;3648:173;;3619:216;3155:696;;;;;;:::o;450:448:5:-;499:23;-1:-1:-1;;655:14:5;711:13;698:27;-1:-1:-1;;;;;;749:27:5;;748:45;744:148;;-1:-1:-1;;;;;851:12:5;843:36;809:72;;744:148;524:374;450:448;:::o;1307:199:7:-;1394:52;1404:5;-1:-1:-1;;;1436:2:7;1440:5;1394:9;:52::i;:::-;1389:111;;1469:20;;-1:-1:-1;;;1469:20:7;;;;;;;;;;;14:131:8;-1:-1:-1;;;;;89:31:8;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:127::-;211:10;206:3;202:20;199:1;192:31;242:4;239:1;232:15;266:4;263:1;256:15;282:275;353:2;347:9;418:2;399:13;;-1:-1:-1;;395:27:8;383:40;;-1:-1:-1;;;;;438:34:8;;474:22;;;435:62;432:88;;;500:18;;:::i;:::-;536:2;529:22;282:275;;-1:-1:-1;282:275:8:o;562:1039::-;648:6;656;664;717:2;705:9;696:7;692:23;688:32;685:52;;;733:1;730;723:12;685:52;772:9;759:23;791:31;816:5;791:31;:::i;:::-;841:5;-1:-1:-1;865:2:8;904:18;;;891:32;932:33;891:32;932:33;:::i;:::-;984:7;-1:-1:-1;1042:2:8;1027:18;;1014:32;-1:-1:-1;;;;;1095:14:8;;;1092:34;;;1122:1;1119;1112:12;1092:34;1160:6;1149:9;1145:22;1135:32;;1205:7;1198:4;1194:2;1190:13;1186:27;1176:55;;1227:1;1224;1217:12;1176:55;1263:2;1250:16;1285:2;1281;1278:10;1275:36;;;1291:18;;:::i;:::-;1333:53;1376:2;1357:13;;-1:-1:-1;;1353:27:8;1349:36;;1333:53;:::i;:::-;1320:66;;1409:2;1402:5;1395:17;1449:7;1444:2;1439;1435;1431:11;1427:20;1424:33;1421:53;;;1470:1;1467;1460:12;1421:53;1525:2;1520;1516;1512:11;1507:2;1500:5;1496:14;1483:45;1569:1;1564:2;1559;1552:5;1548:14;1544:23;1537:34;;1590:5;1580:15;;;;;562:1039;;;;;:::o;1606:401::-;1701:6;1709;1762:2;1750:9;1741:7;1737:23;1733:32;1730:52;;;1778:1;1775;1768:12;1730:52;1810:9;1804:16;1829:31;1854:5;1829:31;:::i;:::-;1929:2;1914:18;;1908:25;1879:5;;-1:-1:-1;1942:33:8;1908:25;1942:33;:::i;:::-;1994:7;1984:17;;;1606:401;;;;;:::o;2012:203::-;-1:-1:-1;;;;;2176:32:8;;;;2158:51;;2146:2;2131:18;;2012:203::o;2220:184::-;2290:6;2343:2;2331:9;2322:7;2318:23;2314:32;2311:52;;;2359:1;2356;2349:12;2311:52;-1:-1:-1;2382:16:8;;2220:184;-1:-1:-1;2220:184:8:o;3309:936::-;3404:6;3435:2;3478;3466:9;3457:7;3453:23;3449:32;3446:52;;;3494:1;3491;3484:12;3446:52;3521:16;;-1:-1:-1;;;;;3586:14:8;;;3583:34;;;3613:1;3610;3603:12;3583:34;3651:6;3640:9;3636:22;3626:32;;3696:7;3689:4;3685:2;3681:13;3677:27;3667:55;;3718:1;3715;3708:12;3667:55;3747:2;3741:9;3769:2;3765;3762:10;3759:36;;;3775:18;;:::i;:::-;3821:2;3818:1;3814:10;3804:20;;3844:28;3868:2;3864;3860:11;3844:28;:::i;:::-;3906:15;;;3976:11;;;3972:20;;;3937:12;;;;4004:19;;;4001:39;;;4036:1;4033;4026:12;4001:39;4060:11;;;;4080:135;4096:6;4091:3;4088:15;4080:135;;;4162:10;;4150:23;;4113:12;;;;4193;;;;4080:135;;;4234:5;3309:936;-1:-1:-1;;;;;;;;3309:936:8:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220c13ac720138025f0b3ab0b6066d52bf02f2c75efbd237e3647772e15705249a364736f6c63430008110033","offset":1515}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x0e81fbdc460895c4541d1e4d6dcb492ceef121fb67a3d1a0a33b2a420ec30627","blockNumber":"24825060","transactionIndex":"191","deployer":"0xEB33b04b8731966DA91990C681f880F379050f33"},"sources":{"src/adapters/origin/OriginArmAdapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IAdapter} from \"@interfaces/IAdapter.sol\";\nimport {IERC20} from \"@interfaces/IERC20.sol\";\nimport {RefundLib} from \"@libraries/RefundLib.sol\";\nimport {SafeERC20} from \"@libraries/SafeERC20.sol\";\n\n/// @notice Origin ARM swap interface (operator-priced LST/LRT swap pools)\ninterface IOSwap {\n    function swapExactTokensForTokens(\n        address inToken,\n        address outToken,\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address to\n    ) external returns (uint256[] memory amounts);\n}\n\n/// @title OriginArmAdapter\n/// @notice Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum\n/// @dev moreInfo = abi.encode(fromToken, toToken)\n///      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).\n///      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).\n///      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).\n///      Output tokens are sent directly to `to` by the ARM pool.\ncontract OriginArmAdapter is IAdapter {\n    using SafeERC20 for IERC20;\n\n    function sellBase(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function sellQuote(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function _armSwap(address to, address pool, bytes memory moreInfo) internal {\n        (address fromToken, address toToken) = abi.decode(moreInfo, (address, address));\n\n        uint256 fromAmount = IERC20(fromToken).balanceOf(address(this));\n        require(fromAmount > 0, \"OriginArmAdapter: zero balance\");\n\n        IERC20(fromToken).forceApprove(pool, fromAmount);\n\n        // amountOutMin = 0: slippage protection is enforced by the upstream aggregator, not at adapter level\n        // ARM sends outToken directly to `to`\n        IOSwap(pool).swapExactTokensForTokens(fromToken, toToken, fromAmount, 0, to);\n\n        // Reset approval to 0 for safety\n        IERC20(fromToken).forceApprove(pool, 0);\n\n        RefundLib.refund(fromToken);\n    }\n}\n"},"src/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(address to, address pool, bytes memory data) external;\n\n    function sellQuote(address to, address pool, bytes memory data) external;\n}\n"},"src/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"src/libraries/RefundLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeERC20.sol\";\nimport \"@interfaces/IERC20.sol\";\n\nlibrary RefundLib {\n    uint256 private constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 private constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    /// @notice Extract the payer origin address from the last 32 bytes of calldata\n    function getPayerOrigin() internal pure returns (address payerOriginAddr) {\n        uint256 _payerOrigin;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            let size := calldatasize()\n            _payerOrigin := calldataload(sub(size, 32))\n        }\n        if ((_payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            payerOriginAddr = address(uint160(uint256(_payerOrigin) & ADDRESS_MASK));\n        }\n    }\n\n    /// @notice Refund any remaining token dust to the payer origin\n    function refund(address token) internal {\n        address payerOrigin = getPayerOrigin();\n        if (payerOrigin == address(0)) return;\n\n        uint256 dust = IERC20(token).balanceOf(address(this));\n        if (dust > 0) {\n            SafeERC20.safeTransfer(IERC20(token), payerOrigin, dust);\n        }\n    }\n}\n"},"src/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./RevertReasonForwarder.sol\";\nimport \"@interfaces/IDaiLikePermit.sol\";\nimport \"@interfaces/IERC20.sol\";\nimport \"@interfaces/IERC20Permit.sol\";\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (\n                !_makeCall(token, token.approve.selector, spender, 0)\n                    || !_makeCall(token, token.approve.selector, spender, value)\n            ) {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n"},"src/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}\n"},"src/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"},"src/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20Permit {\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n        external;\n\n    function nonces(address owner) external view returns (uint256);\n\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.17+commit.8df45f5f","compilerSettings":{"viaIR":false,"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"runs":1,"enabled":true},"evmVersion":"london","remappings":["forge-std/=lib/forge-std/src/","@adapters/=src/adapters/","@interfaces/=src/interfaces/","@libraries/=src/libraries/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"]},"name":"OriginArmAdapter","fullyQualifiedName":"src/adapters/origin/OriginArmAdapter.sol:OriginArmAdapter"},"abi":[{"name":"ForceApproveFailed","type":"error","inputs":[]},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"name":"sellBase","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sellQuote","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.17+commit.8df45f5f"},"language":"Solidity","output":{"abi":[{"inputs":[],"name":"ForceApproveFailed","type":"error"},{"inputs":[],"name":"SafeTransferFailed","type":"error"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellBase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"bytes","name":"moreInfo","type":"bytes"}],"name":"sellQuote","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"details":"moreInfo = abi.encode(fromToken, toToken)      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).      Output tokens are sent directly to `to` by the ARM pool.","kind":"dev","methods":{},"title":"OriginArmAdapter","version":1},"userdoc":{"kind":"user","methods":{},"notice":"Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum","version":1}},"settings":{"compilationTarget":{"src/adapters/origin/OriginArmAdapter.sol":"OriginArmAdapter"},"evmVersion":"london","libraries":{},"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"enabled":true,"runs":1},"remappings":[":@adapters/=src/adapters/",":@interfaces/=src/interfaces/",":@libraries/=src/libraries/",":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/"]},"sources":{"src/adapters/origin/OriginArmAdapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IAdapter} from \"@interfaces/IAdapter.sol\";\nimport {IERC20} from \"@interfaces/IERC20.sol\";\nimport {RefundLib} from \"@libraries/RefundLib.sol\";\nimport {SafeERC20} from \"@libraries/SafeERC20.sol\";\n\n/// @notice Origin ARM swap interface (operator-priced LST/LRT swap pools)\ninterface IOSwap {\n    function swapExactTokensForTokens(\n        address inToken,\n        address outToken,\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address to\n    ) external returns (uint256[] memory amounts);\n}\n\n/// @title OriginArmAdapter\n/// @notice Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum\n/// @dev moreInfo = abi.encode(fromToken, toToken)\n///      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).\n///      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).\n///      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).\n///      Output tokens are sent directly to `to` by the ARM pool.\ncontract OriginArmAdapter is IAdapter {\n    using SafeERC20 for IERC20;\n\n    function sellBase(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function sellQuote(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function _armSwap(address to, address pool, bytes memory moreInfo) internal {\n        (address fromToken, address toToken) = abi.decode(moreInfo, (address, address));\n\n        uint256 fromAmount = IERC20(fromToken).balanceOf(address(this));\n        require(fromAmount > 0, \"OriginArmAdapter: zero balance\");\n\n        IERC20(fromToken).forceApprove(pool, fromAmount);\n\n        // amountOutMin = 0: slippage protection is enforced by the upstream aggregator, not at adapter level\n        // ARM sends outToken directly to `to`\n        IOSwap(pool).swapExactTokensForTokens(fromToken, toToken, fromAmount, 0, to);\n\n        // Reset approval to 0 for safety\n        IERC20(fromToken).forceApprove(pool, 0);\n\n        RefundLib.refund(fromToken);\n    }\n}\n","keccak256":"0x131cd47f5d9c3346c1b0547516aafe38ed95ffd2d1a1b7fb70e3d575f4256d5b","license":"MIT"},"src/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(address to, address pool, bytes memory data) external;\n\n    function sellQuote(address to, address pool, bytes memory data) external;\n}\n","keccak256":"0xfeeae2ce7f811f7e495b308b08a183c8f39571a358b6f3c58272cba7579748ab","license":"MIT"},"src/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n","keccak256":"0x1be001651ed0bce400ff5e91ba077835cda70f57c4b8c1134c3d60c3147e43fe","license":"MIT"},"src/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n","keccak256":"0x01e006d9e88c0fd1e7d85b71345329d8c0c87897c9293be8db01def9b489d71d","license":"MIT"},"src/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20Permit {\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n        external;\n\n    function nonces(address owner) external view returns (uint256);\n\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n","keccak256":"0xe4629777e2e817aec81911ebad8ffe55db64466c40033554bb65bf3b97b95beb","license":"MIT"},"src/libraries/RefundLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeERC20.sol\";\nimport \"@interfaces/IERC20.sol\";\n\nlibrary RefundLib {\n    uint256 private constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 private constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    /// @notice Extract the payer origin address from the last 32 bytes of calldata\n    function getPayerOrigin() internal pure returns (address payerOriginAddr) {\n        uint256 _payerOrigin;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            let size := calldatasize()\n            _payerOrigin := calldataload(sub(size, 32))\n        }\n        if ((_payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            payerOriginAddr = address(uint160(uint256(_payerOrigin) & ADDRESS_MASK));\n        }\n    }\n\n    /// @notice Refund any remaining token dust to the payer origin\n    function refund(address token) internal {\n        address payerOrigin = getPayerOrigin();\n        if (payerOrigin == address(0)) return;\n\n        uint256 dust = IERC20(token).balanceOf(address(this));\n        if (dust > 0) {\n            SafeERC20.safeTransfer(IERC20(token), payerOrigin, dust);\n        }\n    }\n}\n","keccak256":"0xa351a7b306ef5a7c193dc23dd7c2ea736a2a42f5372b48e0db9f8a40c7c210d2","license":"MIT"},"src/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}\n","keccak256":"0x6820682d0ff833f65bf450bd2d1ab1fb2ee16ccd307dc8e1ff83582ebca2e4bf","license":"MIT"},"src/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./RevertReasonForwarder.sol\";\nimport \"@interfaces/IDaiLikePermit.sol\";\nimport \"@interfaces/IERC20.sol\";\nimport \"@interfaces/IERC20Permit.sol\";\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (\n                !_makeCall(token, token.approve.selector, spender, 0)\n                    || !_makeCall(token, token.approve.selector, spender, value)\n            ) {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n","keccak256":"0x2054e5704f6beb394c8c5218636ef362a8930413b795b93e4058c9d79b7ef1e8","license":"MIT"}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"userdoc":{"kind":"user","notice":"Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum","methods":{},"version":1},"devdoc":{"kind":"dev","title":"OriginArmAdapter","details":"moreInfo = abi.encode(fromToken, toToken)      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).      Output tokens are sent directly to `to` by the ARM pool.","methods":{},"version":1},"sourceIds":{"src/interfaces/IERC20.sol":{"id":3},"src/interfaces/IAdapter.sol":{"id":1},"src/libraries/RefundLib.sol":{"id":5},"src/libraries/SafeERC20.sol":{"id":7},"src/interfaces/IERC20Permit.sol":{"id":4},"src/interfaces/IDaiLikePermit.sol":{"id":2},"src/libraries/RevertReasonForwarder.sol":{"id":6},"src/adapters/origin/OriginArmAdapter.sol":{"id":0}},"additionalInput":null,"stdJsonInput":{"sources":{"src/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20 {\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    function name() external view returns (string memory);\n\n    function symbol() external view returns (string memory);\n\n    function decimals() external view returns (uint8);\n\n    function totalSupply() external view returns (uint256);\n\n    function balanceOf(address owner) external view returns (uint256);\n\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    function approve(address spender, uint256 value) external returns (bool);\n\n    function transfer(address to, uint256 value) external returns (bool);\n\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"src/interfaces/IAdapter.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\npragma abicoder v2;\n\ninterface IAdapter {\n    function sellBase(address to, address pool, bytes memory data) external;\n\n    function sellQuote(address to, address pool, bytes memory data) external;\n}\n"},"src/libraries/RefundLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./SafeERC20.sol\";\nimport \"@interfaces/IERC20.sol\";\n\nlibrary RefundLib {\n    uint256 private constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\n    uint256 private constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\n\n    /// @notice Extract the payer origin address from the last 32 bytes of calldata\n    function getPayerOrigin() internal pure returns (address payerOriginAddr) {\n        uint256 _payerOrigin;\n        // solhint-disable-next-line no-inline-assembly\n        assembly {\n            let size := calldatasize()\n            _payerOrigin := calldataload(sub(size, 32))\n        }\n        if ((_payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\n            payerOriginAddr = address(uint160(uint256(_payerOrigin) & ADDRESS_MASK));\n        }\n    }\n\n    /// @notice Refund any remaining token dust to the payer origin\n    function refund(address token) internal {\n        address payerOrigin = getPayerOrigin();\n        if (payerOrigin == address(0)) return;\n\n        uint256 dust = IERC20(token).balanceOf(address(this));\n        if (dust > 0) {\n            SafeERC20.safeTransfer(IERC20(token), payerOrigin, dust);\n        }\n    }\n}\n"},"src/libraries/SafeERC20.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport \"./RevertReasonForwarder.sol\";\nimport \"@interfaces/IDaiLikePermit.sol\";\nimport \"@interfaces/IERC20.sol\";\nimport \"@interfaces/IERC20Permit.sol\";\n\nlibrary SafeERC20 {\n    error SafeTransferFailed();\n    error SafeTransferFromFailed();\n    error ForceApproveFailed();\n    error SafeIncreaseAllowanceFailed();\n    error SafeDecreaseAllowanceFailed();\n    error SafePermitBadLength();\n\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\n        bytes4 selector = token.transferFrom.selector;\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), from)\n            mstore(add(data, 0x24), to)\n            mstore(add(data, 0x44), amount)\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n        if (!success) revert SafeTransferFromFailed();\n    }\n\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\n            revert SafeTransferFailed();\n        }\n    }\n\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\n        forceApprove(token, spender, value);\n    }\n\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\n            if (\n                !_makeCall(token, token.approve.selector, spender, 0)\n                    || !_makeCall(token, token.approve.selector, spender, value)\n            ) {\n                revert ForceApproveFailed();\n            }\n        }\n    }\n\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\n        forceApprove(token, spender, allowance + value);\n    }\n\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 allowance = token.allowance(address(this), spender);\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\n        forceApprove(token, spender, allowance - value);\n    }\n\n    function safePermit(IERC20 token, bytes calldata permit) internal {\n        bool success;\n        if (permit.length == 32 * 7) {\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\n        } else if (permit.length == 32 * 8) {\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\n        } else {\n            revert SafePermitBadLength();\n        }\n        if (!success) RevertReasonForwarder.reRevert();\n    }\n\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            mstore(add(data, 0x04), to)\n            mstore(add(data, 0x24), amount)\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let len := add(4, args.length)\n            let data := mload(0x40)\n\n            mstore(data, selector)\n            calldatacopy(add(data, 0x04), args.offset, args.length)\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\n            if success {\n                switch returndatasize()\n                case 0 { success := gt(extcodesize(token), 0) }\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\n            }\n        }\n    }\n}\n"},"src/interfaces/IERC20Permit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IERC20Permit {\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\n        external;\n\n    function nonces(address owner) external view returns (uint256);\n\n    // solhint-disable-next-line func-name-mixedcase\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\n}\n"},"src/interfaces/IDaiLikePermit.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IDaiLikePermit {\n    function permit(\n        address holder,\n        address spender,\n        uint256 nonce,\n        uint256 expiry,\n        bool allowed,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) external;\n}\n"},"src/libraries/RevertReasonForwarder.sol":{"content":"/// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nlibrary RevertReasonForwarder {\n    function reRevert() internal pure {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // solhint-disable-line no-inline-assembly\n            let ptr := mload(0x40)\n            returndatacopy(ptr, 0, returndatasize())\n            revert(ptr, returndatasize())\n        }\n    }\n}\n"},"src/adapters/origin/OriginArmAdapter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.17;\n\nimport {IAdapter} from \"@interfaces/IAdapter.sol\";\nimport {IERC20} from \"@interfaces/IERC20.sol\";\nimport {RefundLib} from \"@libraries/RefundLib.sol\";\nimport {SafeERC20} from \"@libraries/SafeERC20.sol\";\n\n/// @notice Origin ARM swap interface (operator-priced LST/LRT swap pools)\ninterface IOSwap {\n    function swapExactTokensForTokens(\n        address inToken,\n        address outToken,\n        uint256 amountIn,\n        uint256 amountOutMin,\n        address to\n    ) external returns (uint256[] memory amounts);\n}\n\n/// @title OriginArmAdapter\n/// @notice Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum\n/// @dev moreInfo = abi.encode(fromToken, toToken)\n///      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).\n///      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).\n///      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).\n///      Output tokens are sent directly to `to` by the ARM pool.\ncontract OriginArmAdapter is IAdapter {\n    using SafeERC20 for IERC20;\n\n    function sellBase(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function sellQuote(address to, address pool, bytes memory moreInfo) external override {\n        _armSwap(to, pool, moreInfo);\n    }\n\n    function _armSwap(address to, address pool, bytes memory moreInfo) internal {\n        (address fromToken, address toToken) = abi.decode(moreInfo, (address, address));\n\n        uint256 fromAmount = IERC20(fromToken).balanceOf(address(this));\n        require(fromAmount > 0, \"OriginArmAdapter: zero balance\");\n\n        IERC20(fromToken).forceApprove(pool, fromAmount);\n\n        // amountOutMin = 0: slippage protection is enforced by the upstream aggregator, not at adapter level\n        // ARM sends outToken directly to `to`\n        IOSwap(pool).swapExactTokensForTokens(fromToken, toToken, fromAmount, 0, to);\n\n        // Reset approval to 0 for safety\n        IERC20(fromToken).forceApprove(pool, 0);\n\n        RefundLib.refund(fromToken);\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"bytecodeHash":"ipfs","useLiteralContent":true},"optimizer":{"runs":1,"enabled":true},"evmVersion":"london","remappings":["forge-std/=lib/forge-std/src/","@adapters/=src/adapters/","@interfaces/=src/interfaces/","@libraries/=src/libraries/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"]}},"stdJsonOutput":{"sources":{"src/interfaces/IERC20.sol":{"id":3},"src/interfaces/IAdapter.sol":{"id":1},"src/libraries/RefundLib.sol":{"id":5},"src/libraries/SafeERC20.sol":{"id":7},"src/interfaces/IERC20Permit.sol":{"id":4},"src/interfaces/IDaiLikePermit.sol":{"id":2},"src/libraries/RevertReasonForwarder.sol":{"id":6},"src/adapters/origin/OriginArmAdapter.sol":{"id":0}},"contracts":{"src/adapters/origin/OriginArmAdapter.sol":{"OriginArmAdapter":{"abi":[{"name":"ForceApproveFailed","type":"error","inputs":[]},{"name":"SafeTransferFailed","type":"error","inputs":[]},{"name":"sellBase","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"sellQuote","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"pool","type":"address","internalType":"address"},{"name":"moreInfo","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.17+commit.8df45f5f\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"ForceApproveFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SafeTransferFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"moreInfo\",\"type\":\"bytes\"}],\"name\":\"sellBase\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pool\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"moreInfo\",\"type\":\"bytes\"}],\"name\":\"sellQuote\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"moreInfo = abi.encode(fromToken, toToken)      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).      Output tokens are sent directly to `to` by the ARM pool.\",\"kind\":\"dev\",\"methods\":{},\"title\":\"OriginArmAdapter\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/adapters/origin/OriginArmAdapter.sol\":\"OriginArmAdapter\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1},\"remappings\":[\":@adapters/=src/adapters/\",\":@interfaces/=src/interfaces/\",\":@libraries/=src/libraries/\",\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"]},\"sources\":{\"src/adapters/origin/OriginArmAdapter.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.17;\\n\\nimport {IAdapter} from \\\"@interfaces/IAdapter.sol\\\";\\nimport {IERC20} from \\\"@interfaces/IERC20.sol\\\";\\nimport {RefundLib} from \\\"@libraries/RefundLib.sol\\\";\\nimport {SafeERC20} from \\\"@libraries/SafeERC20.sol\\\";\\n\\n/// @notice Origin ARM swap interface (operator-priced LST/LRT swap pools)\\ninterface IOSwap {\\n    function swapExactTokensForTokens(\\n        address inToken,\\n        address outToken,\\n        uint256 amountIn,\\n        uint256 amountOutMin,\\n        address to\\n    ) external returns (uint256[] memory amounts);\\n}\\n\\n/// @title OriginArmAdapter\\n/// @notice Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum\\n/// @dev moreInfo = abi.encode(fromToken, toToken)\\n///      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).\\n///      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).\\n///      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).\\n///      Output tokens are sent directly to `to` by the ARM pool.\\ncontract OriginArmAdapter is IAdapter {\\n    using SafeERC20 for IERC20;\\n\\n    function sellBase(address to, address pool, bytes memory moreInfo) external override {\\n        _armSwap(to, pool, moreInfo);\\n    }\\n\\n    function sellQuote(address to, address pool, bytes memory moreInfo) external override {\\n        _armSwap(to, pool, moreInfo);\\n    }\\n\\n    function _armSwap(address to, address pool, bytes memory moreInfo) internal {\\n        (address fromToken, address toToken) = abi.decode(moreInfo, (address, address));\\n\\n        uint256 fromAmount = IERC20(fromToken).balanceOf(address(this));\\n        require(fromAmount > 0, \\\"OriginArmAdapter: zero balance\\\");\\n\\n        IERC20(fromToken).forceApprove(pool, fromAmount);\\n\\n        // amountOutMin = 0: slippage protection is enforced by the upstream aggregator, not at adapter level\\n        // ARM sends outToken directly to `to`\\n        IOSwap(pool).swapExactTokensForTokens(fromToken, toToken, fromAmount, 0, to);\\n\\n        // Reset approval to 0 for safety\\n        IERC20(fromToken).forceApprove(pool, 0);\\n\\n        RefundLib.refund(fromToken);\\n    }\\n}\\n\",\"keccak256\":\"0x131cd47f5d9c3346c1b0547516aafe38ed95ffd2d1a1b7fb70e3d575f4256d5b\",\"license\":\"MIT\"},\"src/interfaces/IAdapter.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\npragma abicoder v2;\\n\\ninterface IAdapter {\\n    function sellBase(address to, address pool, bytes memory data) external;\\n\\n    function sellQuote(address to, address pool, bytes memory data) external;\\n}\\n\",\"keccak256\":\"0xfeeae2ce7f811f7e495b308b08a183c8f39571a358b6f3c58272cba7579748ab\",\"license\":\"MIT\"},\"src/interfaces/IDaiLikePermit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IDaiLikePermit {\\n    function permit(\\n        address holder,\\n        address spender,\\n        uint256 nonce,\\n        uint256 expiry,\\n        bool allowed,\\n        uint8 v,\\n        bytes32 r,\\n        bytes32 s\\n    ) external;\\n}\\n\",\"keccak256\":\"0x1be001651ed0bce400ff5e91ba077835cda70f57c4b8c1134c3d60c3147e43fe\",\"license\":\"MIT\"},\"src/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IERC20 {\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    function name() external view returns (string memory);\\n\\n    function symbol() external view returns (string memory);\\n\\n    function decimals() external view returns (uint8);\\n\\n    function totalSupply() external view returns (uint256);\\n\\n    function balanceOf(address owner) external view returns (uint256);\\n\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x01e006d9e88c0fd1e7d85b71345329d8c0c87897c9293be8db01def9b489d71d\",\"license\":\"MIT\"},\"src/interfaces/IERC20Permit.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\ninterface IERC20Permit {\\n    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)\\n        external;\\n\\n    function nonces(address owner) external view returns (uint256);\\n\\n    // solhint-disable-next-line func-name-mixedcase\\n    function DOMAIN_SEPARATOR() external view returns (bytes32);\\n}\\n\",\"keccak256\":\"0xe4629777e2e817aec81911ebad8ffe55db64466c40033554bb65bf3b97b95beb\",\"license\":\"MIT\"},\"src/libraries/RefundLib.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./SafeERC20.sol\\\";\\nimport \\\"@interfaces/IERC20.sol\\\";\\n\\nlibrary RefundLib {\\n    uint256 private constant ORIGIN_PAYER = 0x3ca20afc2ccc0000000000000000000000000000000000000000000000000000;\\n    uint256 private constant ADDRESS_MASK = 0x000000000000000000000000ffffffffffffffffffffffffffffffffffffffff;\\n\\n    /// @notice Extract the payer origin address from the last 32 bytes of calldata\\n    function getPayerOrigin() internal pure returns (address payerOriginAddr) {\\n        uint256 _payerOrigin;\\n        // solhint-disable-next-line no-inline-assembly\\n        assembly {\\n            let size := calldatasize()\\n            _payerOrigin := calldataload(sub(size, 32))\\n        }\\n        if ((_payerOrigin & ORIGIN_PAYER) == ORIGIN_PAYER) {\\n            payerOriginAddr = address(uint160(uint256(_payerOrigin) & ADDRESS_MASK));\\n        }\\n    }\\n\\n    /// @notice Refund any remaining token dust to the payer origin\\n    function refund(address token) internal {\\n        address payerOrigin = getPayerOrigin();\\n        if (payerOrigin == address(0)) return;\\n\\n        uint256 dust = IERC20(token).balanceOf(address(this));\\n        if (dust > 0) {\\n            SafeERC20.safeTransfer(IERC20(token), payerOrigin, dust);\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xa351a7b306ef5a7c193dc23dd7c2ea736a2a42f5372b48e0db9f8a40c7c210d2\",\"license\":\"MIT\"},\"src/libraries/RevertReasonForwarder.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nlibrary RevertReasonForwarder {\\n    function reRevert() internal pure {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            // solhint-disable-line no-inline-assembly\\n            let ptr := mload(0x40)\\n            returndatacopy(ptr, 0, returndatasize())\\n            revert(ptr, returndatasize())\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x6820682d0ff833f65bf450bd2d1ab1fb2ee16ccd307dc8e1ff83582ebca2e4bf\",\"license\":\"MIT\"},\"src/libraries/SafeERC20.sol\":{\"content\":\"/// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.0;\\n\\nimport \\\"./RevertReasonForwarder.sol\\\";\\nimport \\\"@interfaces/IDaiLikePermit.sol\\\";\\nimport \\\"@interfaces/IERC20.sol\\\";\\nimport \\\"@interfaces/IERC20Permit.sol\\\";\\n\\nlibrary SafeERC20 {\\n    error SafeTransferFailed();\\n    error SafeTransferFromFailed();\\n    error ForceApproveFailed();\\n    error SafeIncreaseAllowanceFailed();\\n    error SafeDecreaseAllowanceFailed();\\n    error SafePermitBadLength();\\n\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 amount) internal {\\n        bytes4 selector = token.transferFrom.selector;\\n        bool success;\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            // solhint-disable-line no-inline-assembly\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            mstore(add(data, 0x04), from)\\n            mstore(add(data, 0x24), to)\\n            mstore(add(data, 0x44), amount)\\n            success := call(gas(), token, 0, data, 100, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n        if (!success) revert SafeTransferFromFailed();\\n    }\\n\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        if (!_makeCall(token, token.transfer.selector, to, value)) {\\n            revert SafeTransferFailed();\\n        }\\n    }\\n\\n    function safeApprove(IERC20 token, address spender, uint256 value) internal {\\n        forceApprove(token, spender, value);\\n    }\\n\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        if (!_makeCall(token, token.approve.selector, spender, value)) {\\n            if (\\n                !_makeCall(token, token.approve.selector, spender, 0)\\n                    || !_makeCall(token, token.approve.selector, spender, value)\\n            ) {\\n                revert ForceApproveFailed();\\n            }\\n        }\\n    }\\n\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 allowance = token.allowance(address(this), spender);\\n        if (value > type(uint256).max - allowance) revert SafeIncreaseAllowanceFailed();\\n        forceApprove(token, spender, allowance + value);\\n    }\\n\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 allowance = token.allowance(address(this), spender);\\n        if (value > allowance) revert SafeDecreaseAllowanceFailed();\\n        forceApprove(token, spender, allowance - value);\\n    }\\n\\n    function safePermit(IERC20 token, bytes calldata permit) internal {\\n        bool success;\\n        if (permit.length == 32 * 7) {\\n            success = _makeCalldataCall(token, IERC20Permit.permit.selector, permit);\\n        } else if (permit.length == 32 * 8) {\\n            success = _makeCalldataCall(token, IDaiLikePermit.permit.selector, permit);\\n        } else {\\n            revert SafePermitBadLength();\\n        }\\n        if (!success) RevertReasonForwarder.reRevert();\\n    }\\n\\n    function _makeCall(IERC20 token, bytes4 selector, address to, uint256 amount) private returns (bool success) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            // solhint-disable-line no-inline-assembly\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            mstore(add(data, 0x04), to)\\n            mstore(add(data, 0x24), amount)\\n            success := call(gas(), token, 0, data, 0x44, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n    }\\n\\n    function _makeCalldataCall(IERC20 token, bytes4 selector, bytes calldata args) private returns (bool success) {\\n        /// @solidity memory-safe-assembly\\n        assembly {\\n            // solhint-disable-line no-inline-assembly\\n            let len := add(4, args.length)\\n            let data := mload(0x40)\\n\\n            mstore(data, selector)\\n            calldatacopy(add(data, 0x04), args.offset, args.length)\\n            success := call(gas(), token, 0, data, len, 0x0, 0x20)\\n            if success {\\n                switch returndatasize()\\n                case 0 { success := gt(extcodesize(token), 0) }\\n                default { success := and(gt(returndatasize(), 31), eq(mload(0), 1)) }\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x2054e5704f6beb394c8c5218636ef362a8930413b795b93e4058c9d79b7ef1e8\",\"license\":\"MIT\"}},\"version\":1}","userdoc":{"kind":"user","notice":"Adapter for Origin ARM (Automated Redemption Manager) pools on Ethereum","methods":{},"version":1},"devdoc":{"kind":"dev","title":"OriginArmAdapter","details":"moreInfo = abi.encode(fromToken, toToken)      Uses swapExactTokensForTokens() with exact input (amountIn = adapter's fromToken balance).      amountOutMin is set to 0 (slippage protection enforced upstream by the aggregator).      ARM pools use transferFrom to pull inToken (requires approve, not pre-transfer).      Output tokens are sent directly to `to` by the ARM pool.","methods":{},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"1086:1098:0:-:0;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1086:1098:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1163:130;;;;;;:::i;:::-;;:::i;:::-;;;1258:28;1267:2;1271:4;1277:8;1258;:28::i;:::-;1163:130;;;:::o;1436:746::-;1523:17;1542:15;1572:8;1561:40;;;;;;;;;;;;:::i;:::-;1522:79;;;;1612:18;1640:9;-1:-1:-1;;;;;1633:27:0;;1669:4;1633:42;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1612:63;;1706:1;1693:10;:14;1685:57;;;;-1:-1:-1;;;1685:57:0;;2611:2:8;1685:57:0;;;2593:21:8;2650:2;2630:18;;;2623:30;2689:32;2669:18;;;2662:60;2739:18;;1685:57:0;;;;;;;;1753:48;-1:-1:-1;;;;;1753:30:0;;1784:4;1790:10;1753:30;:48::i;:::-;1969:76;;-1:-1:-1;;;1969:76:0;;-1:-1:-1;;;;;3091:15:8;;;1969:76:0;;;3073:34:8;3143:15;;;3123:18;;;3116:43;3175:18;;;3168:34;;;2039:1:0;3218:18:8;;;3211:34;3282:15;;;3261:19;;;3254:44;1969:37:0;;;;;3007:19:8;;1969:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1969:76:0;;;;;;;;;;;;:::i;:::-;-1:-1:-1;2098:39:0;-1:-1:-1;;;;;2098:30:0;;2129:4;2135:1;2098:30;:39::i;:::-;2148:27;2165:9;2148:16;:27::i;:::-;1512:670;;;1436:746;;;:::o;1646:410:7:-;1738:56;1748:5;-1:-1:-1;;;1779:7:7;1788:5;1738:9;:56::i;:::-;1733:317;;1832:52;1842:5;-1:-1:-1;;;1873:7:7;1882:1;1832:9;:52::i;:::-;1831:53;:134;;;-1:-1:-1;1909:56:7;1919:5;-1:-1:-1;;;1950:7:7;1959:5;1909:9;:56::i;:::-;1908:57;1831:134;1810:230;;;2005:20;;-1:-1:-1;;;2005:20:7;;;;;;;;;;;972:310:5;1022:19;1044:16;:14;:16::i;:::-;1022:38;-1:-1:-1;;;;;;1074:25:5;;1070:38;;1101:7;972:310;:::o;1070:38::-;1133;;-1:-1:-1;;;1133:38:5;;1118:12;;-1:-1:-1;;;;;1133:23:5;;;;;:38;;1165:4;;1133:38;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1118:53;-1:-1:-1;1185:8:5;;1181:95;;1209:56;1239:5;1247:11;1260:4;1209:22;:56::i;3155:696:7:-;3250:12;3413:4;3407:11;3445:8;3439:4;3432:22;3491:2;3484:4;3478;3474:15;3467:27;3531:6;3524:4;3518;3514:15;3507:31;3601:4;3596:3;3590:4;3584;3581:1;3574:5;3567;3562:44;3551:55;;;3622:7;3619:216;;;3655:16;3688:47;;;;3816:1;3812;3806:8;3803:15;3798:2;3780:16;3777:24;3773:46;3762:57;;3648:173;;3688:47;3731:1;3723:5;3711:18;3708:25;3697:36;;3648:173;;3619:216;3155:696;;;;;;:::o;450:448:5:-;499:23;-1:-1:-1;;655:14:5;711:13;698:27;-1:-1:-1;;;;;;749:27:5;;748:45;744:148;;-1:-1:-1;;;;;851:12:5;843:36;809:72;;744:148;524:374;450:448;:::o;1307:199:7:-;1394:52;1404:5;-1:-1:-1;;;1436:2:7;1440:5;1394:9;:52::i;:::-;1389:111;;1469:20;;-1:-1:-1;;;1469:20:7;;;;;;;;;;;14:131:8;-1:-1:-1;;;;;89:31:8;;79:42;;69:70;;135:1;132;125:12;69:70;14:131;:::o;150:127::-;211:10;206:3;202:20;199:1;192:31;242:4;239:1;232:15;266:4;263:1;256:15;282:275;353:2;347:9;418:2;399:13;;-1:-1:-1;;395:27:8;383:40;;-1:-1:-1;;;;;438:34:8;;474:22;;;435:62;432:88;;;500:18;;:::i;:::-;536:2;529:22;282:275;;-1:-1:-1;282:275:8:o;562:1039::-;648:6;656;664;717:2;705:9;696:7;692:23;688:32;685:52;;;733:1;730;723:12;685:52;772:9;759:23;791:31;816:5;791:31;:::i;:::-;841:5;-1:-1:-1;865:2:8;904:18;;;891:32;932:33;891:32;932:33;:::i;:::-;984:7;-1:-1:-1;1042:2:8;1027:18;;1014:32;-1:-1:-1;;;;;1095:14:8;;;1092:34;;;1122:1;1119;1112:12;1092:34;1160:6;1149:9;1145:22;1135:32;;1205:7;1198:4;1194:2;1190:13;1186:27;1176:55;;1227:1;1224;1217:12;1176:55;1263:2;1250:16;1285:2;1281;1278:10;1275:36;;;1291:18;;:::i;:::-;1333:53;1376:2;1357:13;;-1:-1:-1;;1353:27:8;1349:36;;1333:53;:::i;:::-;1320:66;;1409:2;1402:5;1395:17;1449:7;1444:2;1439;1435;1431:11;1427:20;1424:33;1421:53;;;1470:1;1467;1460:12;1421:53;1525:2;1520;1516;1512:11;1507:2;1500:5;1496:14;1483:45;1569:1;1564:2;1559;1552:5;1548:14;1544:23;1537:34;;1590:5;1580:15;;;;;562:1039;;;;;:::o;1606:401::-;1701:6;1709;1762:2;1750:9;1741:7;1737:23;1733:32;1730:52;;;1778:1;1775;1768:12;1730:52;1810:9;1804:16;1829:31;1854:5;1829:31;:::i;:::-;1929:2;1914:18;;1908:25;1879:5;;-1:-1:-1;1942:33:8;1908:25;1942:33;:::i;:::-;1994:7;1984:17;;;1606:401;;;;;:::o;2012:203::-;-1:-1:-1;;;;;2176:32:8;;;;2158:51;;2146:2;2131:18;;2012:203::o;2220:184::-;2290:6;2343:2;2331:9;2322:7;2318:23;2314:32;2311:52;;;2359:1;2356;2349:12;2311:52;-1:-1:-1;2382:16:8;;2220:184;-1:-1:-1;2220:184:8:o;3309:936::-;3404:6;3435:2;3478;3466:9;3457:7;3453:23;3449:32;3446:52;;;3494:1;3491;3484:12;3446:52;3521:16;;-1:-1:-1;;;;;3586:14:8;;;3583:34;;;3613:1;3610;3603:12;3583:34;3651:6;3640:9;3636:22;3626:32;;3696:7;3689:4;3685:2;3681:13;3677:27;3667:55;;3718:1;3715;3708:12;3667:55;3747:2;3741:9;3769:2;3765;3762:10;3759:36;;;3775:18;;:::i;:::-;3821:2;3818:1;3814:10;3804:20;;3844:28;3868:2;3864;3860:11;3844:28;:::i;:::-;3906:15;;;3976:11;;;3972:20;;;3937:12;;;;4004:19;;;4001:39;;;4036:1;4033;4026:12;4001:39;4060:11;;;;4080:135;4096:6;4091:3;4088:15;4080:135;;;4162:10;;4150:23;;4113:12;;;;4193;;;;4080:135;;;4234:5;3309:936;-1:-1:-1;;;;;;;;3309:936:8:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"sellBase(address,address,bytes)","signatureHash4":"0x30e6ae31","signatureHash32":"0x30e6ae317bb74e054afcab0bd57887675415dfd395c5c8a31736e196757b1e81"},{"signature":"sellQuote(address,address,bytes)","signatureHash4":"0x6f7929f2","signatureHash32":"0x6f7929f2b01195712498d48a0811ef40554ee216f994a893f4b2ce9624a6eca8"}],"event":[],"error":[{"signature":"ForceApproveFailed()","signatureHash4":"0x19be9a90","signatureHash32":"0x19be9a90582300ebcdeef94f8f7ab919b96964ca7ca775671973e925d928aa17"},{"signature":"SafeTransferFailed()","signatureHash4":"0xfb7f5079","signatureHash32":"0xfb7f50796995f43b6f601c7bdc661fff3554a3197898a14efb94c31f671088ce"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0x63B3030DddF891892F32c2b87871181f20b72332"}