Branch data Line data Source code
1 : : // SPDX-License-Identifier: MIT
2 : : pragma solidity ^0.8.10;
3 : :
4 : : /**
5 : : * @title CalldataLogic library
6 : : * @author Aave
7 : : * @notice Library to decode calldata, used to optimize calldata size in L2Pool for transaction cost reduction
8 : : */
9 : : library CalldataLogic {
10 : : /**
11 : : * @notice Decodes compressed supply params to standard params
12 : : * @param reservesList The addresses of all the active reserves
13 : : * @param args The packed supply params
14 : : * @return The address of the underlying reserve
15 : : * @return The amount to supply
16 : : * @return The referralCode
17 : : */
18 : : function decodeSupplyParams(
19 : : mapping(uint256 => address) storage reservesList,
20 : : bytes32 args
21 : : ) internal view returns (address, uint256, uint16) {
22 : 1007 : uint16 assetId;
23 : 1007 : uint256 amount;
24 : 1007 : uint16 referralCode;
25 : :
26 : : assembly {
27 : 1007 : assetId := and(args, 0xFFFF)
28 : 1007 : amount := and(shr(16, args), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
29 : 1007 : referralCode := and(shr(144, args), 0xFFFF)
30 : : }
31 : 1007 : return (reservesList[assetId], amount, referralCode);
32 : : }
33 : :
34 : : /**
35 : : * @notice Decodes compressed supply params to standard params along with permit params
36 : : * @param reservesList The addresses of all the active reserves
37 : : * @param args The packed supply with permit params
38 : : * @return The address of the underlying reserve
39 : : * @return The amount to supply
40 : : * @return The referralCode
41 : : * @return The deadline of the permit
42 : : * @return The V value of the permit signature
43 : : */
44 : : function decodeSupplyWithPermitParams(
45 : : mapping(uint256 => address) storage reservesList,
46 : : bytes32 args
47 : : ) internal view returns (address, uint256, uint16, uint256, uint8) {
48 : 1000 : uint256 deadline;
49 : 1000 : uint8 permitV;
50 : :
51 : : assembly {
52 : 1000 : deadline := and(shr(160, args), 0xFFFFFFFF)
53 : 1000 : permitV := and(shr(192, args), 0xFF)
54 : : }
55 : 1000 : (address asset, uint256 amount, uint16 referralCode) = decodeSupplyParams(reservesList, args);
56 : :
57 : 1000 : return (asset, amount, referralCode, deadline, permitV);
58 : : }
59 : :
60 : : /**
61 : : * @notice Decodes compressed withdraw params to standard params
62 : : * @param reservesList The addresses of all the active reserves
63 : : * @param args The packed withdraw params
64 : : * @return The address of the underlying reserve
65 : : * @return The amount to withdraw
66 : : */
67 : : function decodeWithdrawParams(
68 : : mapping(uint256 => address) storage reservesList,
69 : : bytes32 args
70 : : ) internal view returns (address, uint256) {
71 : 2 : uint16 assetId;
72 : 2 : uint256 amount;
73 : : assembly {
74 : 2 : assetId := and(args, 0xFFFF)
75 : 2 : amount := and(shr(16, args), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
76 : : }
77 : 2 : if (amount == type(uint128).max) {
78 : 1 : amount = type(uint256).max;
79 : : }
80 : 2 : return (reservesList[assetId], amount);
81 : : }
82 : :
83 : : /**
84 : : * @notice Decodes compressed borrow params to standard params
85 : : * @param reservesList The addresses of all the active reserves
86 : : * @param args The packed borrow params
87 : : * @return The address of the underlying reserve
88 : : * @return The amount to borrow
89 : : * @return The interestRateMode, 2 for variable debt, 1 is deprecated (changed on v3.2.0)
90 : : * @return The referralCode
91 : : */
92 : : function decodeBorrowParams(
93 : : mapping(uint256 => address) storage reservesList,
94 : : bytes32 args
95 : : ) internal view returns (address, uint256, uint256, uint16) {
96 : 3 : uint16 assetId;
97 : 3 : uint256 amount;
98 : 3 : uint256 interestRateMode;
99 : 3 : uint16 referralCode;
100 : :
101 : : assembly {
102 : 3 : assetId := and(args, 0xFFFF)
103 : 3 : amount := and(shr(16, args), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
104 : 3 : interestRateMode := and(shr(144, args), 0xFF)
105 : 3 : referralCode := and(shr(152, args), 0xFFFF)
106 : : }
107 : :
108 : 3 : return (reservesList[assetId], amount, interestRateMode, referralCode);
109 : : }
110 : :
111 : : /**
112 : : * @notice Decodes compressed repay params to standard params
113 : : * @param reservesList The addresses of all the active reserves
114 : : * @param args The packed repay params
115 : : * @return The address of the underlying reserve
116 : : * @return The amount to repay
117 : : * @return The interestRateMode, 2 for variable debt, 1 is deprecated (changed on v3.2.0)
118 : : */
119 : : function decodeRepayParams(
120 : : mapping(uint256 => address) storage reservesList,
121 : : bytes32 args
122 : : ) internal view returns (address, uint256, uint256) {
123 : 1002 : uint16 assetId;
124 : 1002 : uint256 amount;
125 : 1002 : uint256 interestRateMode;
126 : :
127 : : assembly {
128 : 1002 : assetId := and(args, 0xFFFF)
129 : 1002 : amount := and(shr(16, args), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
130 : 1002 : interestRateMode := and(shr(144, args), 0xFF)
131 : : }
132 : :
133 : 1002 : if (amount == type(uint128).max) {
134 : 2 : amount = type(uint256).max;
135 : : }
136 : :
137 : 1002 : return (reservesList[assetId], amount, interestRateMode);
138 : : }
139 : :
140 : : /**
141 : : * @notice Decodes compressed repay params to standard params along with permit params
142 : : * @param reservesList The addresses of all the active reserves
143 : : * @param args The packed repay with permit params
144 : : * @return The address of the underlying reserve
145 : : * @return The amount to repay
146 : : * @return The interestRateMode, 2 for variable debt, 1 is deprecated (changed on v3.2.0)
147 : : * @return The deadline of the permit
148 : : * @return The V value of the permit signature
149 : : */
150 : : function decodeRepayWithPermitParams(
151 : : mapping(uint256 => address) storage reservesList,
152 : : bytes32 args
153 : : ) internal view returns (address, uint256, uint256, uint256, uint8) {
154 : 1000 : uint256 deadline;
155 : 1000 : uint8 permitV;
156 : :
157 : 1000 : (address asset, uint256 amount, uint256 interestRateMode) = decodeRepayParams(
158 : : reservesList,
159 : : args
160 : : );
161 : :
162 : : assembly {
163 : 1000 : deadline := and(shr(152, args), 0xFFFFFFFF)
164 : 1000 : permitV := and(shr(184, args), 0xFF)
165 : : }
166 : :
167 : 1000 : return (asset, amount, interestRateMode, deadline, permitV);
168 : : }
169 : :
170 : : /**
171 : : * @notice Decodes compressed set user use reserve as collateral params to standard params
172 : : * @param reservesList The addresses of all the active reserves
173 : : * @param args The packed set user use reserve as collateral params
174 : : * @return The address of the underlying reserve
175 : : * @return True if to set using as collateral, false otherwise
176 : : */
177 : : function decodeSetUserUseReserveAsCollateralParams(
178 : : mapping(uint256 => address) storage reservesList,
179 : : bytes32 args
180 : : ) internal view returns (address, bool) {
181 : 1 : uint16 assetId;
182 : 1 : bool useAsCollateral;
183 : : assembly {
184 : 1 : assetId := and(args, 0xFFFF)
185 : 1 : useAsCollateral := and(shr(16, args), 0x1)
186 : : }
187 : 1 : return (reservesList[assetId], useAsCollateral);
188 : : }
189 : :
190 : : /**
191 : : * @notice Decodes compressed liquidation call params to standard params
192 : : * @param reservesList The addresses of all the active reserves
193 : : * @param args1 The first half of packed liquidation call params
194 : : * @param args2 The second half of the packed liquidation call params
195 : : * @return The address of the underlying collateral asset
196 : : * @return The address of the underlying debt asset
197 : : * @return The address of the user to liquidate
198 : : * @return The amount of debt to cover
199 : : * @return True if receiving aTokens, false otherwise
200 : : */
201 : : function decodeLiquidationCallParams(
202 : : mapping(uint256 => address) storage reservesList,
203 : : bytes32 args1,
204 : : bytes32 args2
205 : : ) internal view returns (address, address, address, uint256, bool) {
206 : 1 : uint16 collateralAssetId;
207 : 1 : uint16 debtAssetId;
208 : 1 : address user;
209 : 1 : uint256 debtToCover;
210 : 1 : bool receiveAToken;
211 : :
212 : : assembly {
213 : 1 : collateralAssetId := and(args1, 0xFFFF)
214 : 1 : debtAssetId := and(shr(16, args1), 0xFFFF)
215 : 1 : user := and(shr(32, args1), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
216 : :
217 : 1 : debtToCover := and(args2, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
218 : 1 : receiveAToken := and(shr(128, args2), 0x1)
219 : : }
220 : :
221 : 1 : if (debtToCover == type(uint128).max) {
222 : 1 : debtToCover = type(uint256).max;
223 : : }
224 : :
225 : 1 : return (
226 : : reservesList[collateralAssetId],
227 : : reservesList[debtAssetId],
228 : : user,
229 : : debtToCover,
230 : : receiveAToken
231 : : );
232 : : }
233 : : }
|
