Liquidity Pool Farm Contracts
Fully Audited: All smart contracts used by Liquidus are fully audited by reputational auditing companies.
Farm | Blockchain | Contract | Lock Duration |
|---|---|---|---|
LIQ-BNB LP PancakeSwap | BNB Smart Chain | 0x8B79d987363a3e1EDA2A2eEBb38C242311C6c008 | 1 Month |
LIQ-BUSD LP Apeswap | BNB Smart Chain | 0xB67640F6D742d35650F95E4C0294670E8824adaa | 1 Month |
LIQ-ETH LP Uniswap | Ethereum | 0xd27fAb2323eDB75AF6f4348E3745247E77690E53 | 1 Month |
LIQ-CRO LP Cronaswap | Cronos | 0x1c7fDE0a9619bC81b23cAEF6992288BA5547a34F | 0 Months |
1
// File: @openzeppelin/contracts/utils/Address.sol
2
3
pragma solidity ^0.8.0;
4
5
/**
6
* @dev Collection of functions related to the address type
7
*/
8
library Address {
9
/**
10
* @dev Returns true if `account` is a contract.
11
*
12
* [IMPORTANT]
13
* ====
14
* It is unsafe to assume that an address for which this function returns
15
* false is an externally-owned account (EOA) and not a contract.
16
*
17
* Among others, `isContract` will return false for the following
18
* types of addresses:
19
*
20
* - an externally-owned account
21
* - a contract in construction
22
* - an address where a contract will be created
23
* - an address where a contract lived, but was destroyed
24
* ====
25
*/
26
function isContract(address account) internal view returns (bool) {
27
// This method relies on extcodesize, which returns 0 for contracts in
28
// construction, since the code is only stored at the end of the
29
// constructor execution.
30
31
uint256 size;
32
assembly {
33
size := extcodesize(account)
34
}
35
return size > 0;
36
}
37
38
/**
39
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
40
* `recipient`, forwarding all available gas and reverting on errors.
41
*
42
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
43
* of certain opcodes, possibly making contracts go over the 2300 gas limit
44
* imposed by `transfer`, making them unable to receive funds via
45
* `transfer`. {sendValue} removes this limitation.
46
*
47
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
48
*
49
* IMPORTANT: because control is transferred to `recipient`, care must be
50
* taken to not create reentrancy vulnerabilities. Consider using
51
* {ReentrancyGuard} or the
52
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
53
*/
54
function sendValue(address payable recipient, uint256 amount) internal {
55
require(address(this).balance >= amount, "Address: insufficient balance");
56
57
(bool success, ) = recipient.call{value: amount}("");
58
require(success, "Address: unable to send value, recipient may have reverted");
59
}
60
61
/**
62
* @dev Performs a Solidity function call using a low level `call`. A
63
* plain `call` is an unsafe replacement for a function call: use this
64
* function instead.
65
*
66
* If `target` reverts with a revert reason, it is bubbled up by this
67
* function (like regular Solidity function calls).
68
*
69
* Returns the raw returned data. To convert to the expected return value,
70
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
71
*
72
* Requirements:
73
*
74
* - `target` must be a contract.
75
* - calling `target` with `data` must not revert.
76
*
77
* _Available since v3.1._
78
*/
79
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
80
return functionCall(target, data, "Address: low-level call failed");
81
}
82
83
/**
84
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
85
* `errorMessage` as a fallback revert reason when `target` reverts.
86
*
87
* _Available since v3.1._
88
*/
89
function functionCall(
90
address target,
91
bytes memory data,
92
string memory errorMessage
93
) internal returns (bytes memory) {
94
return functionCallWithValue(target, data, 0, errorMessage);
95
}
96
97
/**
98
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
99
* but also transferring `value` wei to `target`.
100
*
101
* Requirements:
102
*
103
* - the calling contract must have an ETH balance of at least `value`.
104
* - the called Solidity function must be `payable`.
105
*
106
* _Available since v3.1._
107
*/
108
function functionCallWithValue(
109
address target,
110
bytes memory data,
111
uint256 value
112
) internal returns (bytes memory) {
113
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
114
}
115
116
/**
117
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
118
* with `errorMessage` as a fallback revert reason when `target` reverts.
119
*
120
* _Available since v3.1._
121
*/
122
function functionCallWithValue(
123
address target,
124
bytes memory data,
125
uint256 value,
126
string memory errorMessage
127
) internal returns (bytes memory) {
128
require(address(this).balance >= value, "Address: insufficient balance for call");
129
require(isContract(target), "Address: call to non-contract");
130
131
(bool success, bytes memory returndata) = target.call{value: value}(data);
132
return verifyCallResult(success, returndata, errorMessage);
133
}
134
135
/**
136
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
137
* but performing a static call.
138
*
139
* _Available since v3.3._
140
*/
141
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
142
return functionStaticCall(target, data, "Address: low-level static call failed");
143
}
144
145
/**
146
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
147
* but performing a static call.
148
*
149
* _Available since v3.3._
150
*/
151
function functionStaticCall(
152
address target,
153
bytes memory data,
154
string memory errorMessage
155
) internal view returns (bytes memory) {
156
require(isContract(target), "Address: static call to non-contract");
157
158
(bool success, bytes memory returndata) = target.staticcall(data);
159
return verifyCallResult(success, returndata, errorMessage);
160
}
161
162
/**
163
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
164
* but performing a delegate call.
165
*
166
* _Available since v3.4._
167
*/
168
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
169
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
170
}
171
172
/**
173
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
174
* but performing a delegate call.
175
*
176
* _Available since v3.4._
177
*/
178
function functionDelegateCall(
179
address target,
180
bytes memory data,
181
string memory errorMessage
182
) internal returns (bytes memory) {
183
require(isContract(target), "Address: delegate call to non-contract");
184
185
(bool success, bytes memory returndata) = target.delegatecall(data);
186
return verifyCallResult(success, returndata, errorMessage);
187
}
188
189
/**
190
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
191
* revert reason using the provided one.
192
*
193
* _Available since v4.3._
194
*/
195
function verifyCallResult(
196
bool success,
197
bytes memory returndata,
198
string memory errorMessage
199
) internal pure returns (bytes memory) {
200
if (success) {
201
return returndata;
202
} else {
203
// Look for revert reason and bubble it up if present
204
if (returndata.length > 0) {
205
// The easiest way to bubble the revert reason is using memory via assembly
206
207
assembly {
208
let returndata_size := mload(returndata)
209
revert(add(32, returndata), returndata_size)
210
}
211
} else {
212
revert(errorMessage);
213
}
214
}
215
}
216
}
217
218
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
219
220
221
222
pragma solidity ^0.8.0;
223
224
/**
225
* @dev Interface of the ERC20 standard as defined in the EIP.
226
*/
227
interface IERC20 {
228
/**
229
* @dev Returns the amount of tokens in existence.
230
*/
231
function totalSupply() external view returns (uint256);
232
233
/**
234
* @dev Returns the amount of tokens owned by `account`.
235
*/
236
function balanceOf(address account) external view returns (uint256);
237
238
/**
239
* @dev Moves `amount` tokens from the caller's account to `recipient`.
240
*
241
* Returns a boolean value indicating whether the operation succeeded.
242
*
243
* Emits a {Transfer} event.
244
*/
245
function transfer(address recipient, uint256 amount) external returns (bool);
246
247
/**
248
* @dev Returns the remaining number of tokens that `spender` will be
249
* allowed to spend on behalf of `owner` through {transferFrom}. This is
250
* zero by default.
251
*
252
* This value changes when {approve} or {transferFrom} are called.
253
*/
254
function allowance(address owner, address spender) external view returns (uint256);
255
256
/**
257
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
258
*
259
* Returns a boolean value indicating whether the operation succeeded.
260
*
261
* IMPORTANT: Beware that changing an allowance with this method brings the risk
262
* that someone may use both the old and the new allowance by unfortunate
263
* transaction ordering. One possible solution to mitigate this race
264
* condition is to first reduce the spender's allowance to 0 and set the
265
* desired value afterwards:
266
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
267
*
268
* Emits an {Approval} event.
269
*/
270
function approve(address spender, uint256 amount) external returns (bool);
271
272
/**
273
* @dev Moves `amount` tokens from `sender` to `recipient` using the
274
* allowance mechanism. `amount` is then deducted from the caller's
275
* allowance.
276
*
277
* Returns a boolean value indicating whether the operation succeeded.
278
*
279
* Emits a {Transfer} event.
280
*/
281
function transferFrom(
282
address sender,
283
address recipient,
284
uint256 amount
285
) external returns (bool);
286
287
/**
288
* @dev Emitted when `value` tokens are moved from one account (`from`) to
289
* another (`to`).
290
*
291
* Note that `value` may be zero.
292
*/
293
event Transfer(address indexed from, address indexed to, uint256 value);
294
295
/**
296
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
297
* a call to {approve}. `value` is the new allowance.
298
*/
299
event Approval(address indexed owner, address indexed spender, uint256 value);
300
}
301
302
// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol
303
304
305
306
pragma solidity ^0.8.0;
307
308
309
310
/**
311
* @title SafeERC20
312
* @dev Wrappers around ERC20 operations that throw on failure (when the token
313
* contract returns false). Tokens that return no value (and instead revert or
314
* throw on failure) are also supported, non-reverting calls are assumed to be
315
* successful.
316
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
317
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
318
*/
319
library SafeERC20 {
320
using Address for address;
321
322
function safeTransfer(
323
IERC20 token,
324
address to,
325
uint256 value
326
) internal {
327
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
328
}
329
330
function safeTransferFrom(
331
IERC20 token,
332
address from,
333
address to,
334
uint256 value
335
) internal {
336
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
337
}
338
339
/**
340
* @dev Deprecated. This function has issues similar to the ones found in
341
* {IERC20-approve}, and its usage is discouraged.
342
*
343
* Whenever possible, use {safeIncreaseAllowance} and
344
* {safeDecreaseAllowance} instead.
345
*/
346
function safeApprove(
347
IERC20 token,
348
address spender,
349
uint256 value
350
) internal {
351
// safeApprove should only be called when setting an initial allowance,
352
// or when resetting it to zero. To increase and decrease it, use
353
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
354
require(
355
(value == 0) || (token.allowance(address(this), spender) == 0),
356
"SafeERC20: approve from non-zero to non-zero allowance"
357
);
358
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
359
}
360
361
function safeIncreaseAllowance(
362
IERC20 token,
363
address spender,
364
uint256 value
365
) internal {
366
uint256 newAllowance = token.allowance(address(this), spender) + value;
367
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
368
}
369
370
function safeDecreaseAllowance(
371
IERC20 token,
372
address spender,
373
uint256 value
374
) internal {
375
unchecked {
376
uint256 oldAllowance = token.allowance(address(this), spender);
377
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
378
uint256 newAllowance = oldAllowance - value;
379
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
380
}
381
}
382
383
/**
384
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
385
* on the return value: the return value is optional (but if data is returned, it must not be false).
386
* @param token The token targeted by the call.
387
* @param data The call data (encoded using abi.encode or one of its variants).
388
*/
389
function _callOptionalReturn(IERC20 token, bytes memory data) private {
390
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
391
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
392
// the target address contains contract code and also asserts for success in the low-level call.
393
394
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
395
if (returndata.length > 0) {
396
// Return data is optional
397
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
398
}
399
}
400
}
401
402
// File: @openzeppelin/contracts/utils/math/SafeCast.sol
403
404
405
406
pragma solidity ^0.8.0;
407
408
/**
409
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
410
* checks.
411
*
412
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
413
* easily result in undesired exploitation or bugs, since developers usually
414
* assume that overflows raise errors. `SafeCast` restores this intuition by
415
* reverting the transaction when such an operation overflows.
416
*
417
* Using this library instead of the unchecked operations eliminates an entire
418
* class of bugs, so it's recommended to use it always.
419
*
420
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
421
* all math on `uint256` and `int256` and then downcasting.
422
*/
423
library SafeCast {
424
/**
425
* @dev Returns the downcasted uint224 from uint256, reverting on
426
* overflow (when the input is greater than largest uint224).
427
*
428
* Counterpart to Solidity's `uint224` operator.
429
*
430
* Requirements:
431
*
432
* - input must fit into 224 bits
433
*/
434
function toUint224(uint256 value) internal pure returns (uint224) {
435
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
436
return uint224(value);
437
}
438
439
/**
440
* @dev Returns the downcasted uint128 from uint256, reverting on
441
* overflow (when the input is greater than largest uint128).
442
*
443
* Counterpart to Solidity's `uint128` operator.
444
*
445
* Requirements:
446
*
447
* - input must fit into 128 bits
448
*/
449
function toUint128(uint256 value) internal pure returns (uint128) {
450
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
451
return uint128(value);
452
}
453
454
/**
455
* @dev Returns the downcasted uint96 from uint256, reverting on
456
* overflow (when the input is greater than largest uint96).
457
*
458
* Counterpart to Solidity's `uint96` operator.
459
*
460
* Requirements:
461
*
462
* - input must fit into 96 bits
463
*/
464
function toUint96(uint256 value) internal pure returns (uint96) {
465
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
466
return uint96(value);
467
}
468
469
/**
470
* @dev Returns the downcasted uint64 from uint256, reverting on
471
* overflow (when the input is greater than largest uint64).
472
*
473
* Counterpart to Solidity's `uint64` operator.
474
*
475
* Requirements:
476
*
477
* - input must fit into 64 bits
478
*/
479
function toUint64(uint256 value) internal pure returns (uint64) {
480
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
481
return uint64(value);
482
}
483
484
/**
485
* @dev Returns the downcasted uint32 from uint256, reverting on
486
* overflow (when the input is greater than largest uint32).
487
*
488
* Counterpart to Solidity's `uint32` operator.
489
*
490
* Requirements:
491
*
492
* - input must fit into 32 bits
493
*/
494
function toUint32(uint256 value) internal pure returns (uint32) {
495
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
496
return uint32(value);
497
}
498
499
/**
500
* @dev Returns the downcasted uint16 from uint256, reverting on
501
* overflow (when the input is greater than largest uint16).
502
*
503
* Counterpart to Solidity's `uint16` operator.
504
*
505
* Requirements:
506
*
507
* - input must fit into 16 bits
508
*/
509
function toUint16(uint256 value) internal pure returns (uint16) {
510
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
511
return uint16(value);
512
}
513
514
/**
515
* @dev Returns the downcasted uint8 from uint256, reverting on
516
* overflow (when the input is greater than largest uint8).
517
*
518
* Counterpart to Solidity's `uint8` operator.
519
*
520
* Requirements:
521
*
522
* - input must fit into 8 bits.
523
*/
524
function toUint8(uint256 value) internal pure returns (uint8) {
525
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
526
return uint8(value);
527
}
528
529
/**
530
* @dev Converts a signed int256 into an unsigned uint256.
531
*
532
* Requirements:
533
*
534
* - input must be greater than or equal to 0.
535
*/
536
function toUint256(int256 value) internal pure returns (uint256) {
537
require(value >= 0, "SafeCast: value must be positive");
538
return uint256(value);
539
}
540
541
/**
542
* @dev Returns the downcasted int128 from int256, reverting on
543
* overflow (when the input is less than smallest int128 or
544
* greater than largest int128).
545
*
546
* Counterpart to Solidity's `int128` operator.
547
*
548
* Requirements:
549
*
550
* - input must fit into 128 bits
551
*
552
* _Available since v3.1._
553
*/
554
function toInt128(int256 value) internal pure returns (int128) {
555
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
556
return int128(value);
557
}
558
559
/**
560
* @dev Returns the downcasted int64 from int256, reverting on
561
* overflow (when the input is less than smallest int64 or
562
* greater than largest int64).
563
*
564
* Counterpart to Solidity's `int64` operator.
565
*
566
* Requirements:
567
*
568
* - input must fit into 64 bits
569
*
570
* _Available since v3.1._
571
*/
572
function toInt64(int256 value) internal pure returns (int64) {
573
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
574
return int64(value);
575
}
576
577
/**
578
* @dev Returns the downcasted int32 from int256, reverting on
579
* overflow (when the input is less than smallest int32 or
580
* greater than largest int32).
581
*
582
* Counterpart to Solidity's `int32` operator.
583
*
584
* Requirements:
585
*
586
* - input must fit into 32 bits
587
*
588
* _Available since v3.1._
589
*/
590
function toInt32(int256 value) internal pure returns (int32) {
591
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
592
return int32(value);
593
}
594
595
/**
596
* @dev Returns the downcasted int16 from int256, reverting on
597
* overflow (when the input is less than smallest int16 or
598
* greater than largest int16).
599
*
600
* Counterpart to Solidity's `int16` operator.
601
*
602
* Requirements:
603
*
604
* - input must fit into 16 bits
605
*
606
* _Available since v3.1._
607
*/
608
function toInt16(int256 value) internal pure returns (int16) {
609
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
610
return int16(value);
611
}
612
613
/**
614
* @dev Returns the downcasted int8 from int256, reverting on
615
* overflow (when the input is less than smallest int8 or
616
* greater than largest int8).
617
*
618
* Counterpart to Solidity's `int8` operator.
619
*
620
* Requirements:
621
*
622
* - input must fit into 8 bits.
623
*
624
* _Available since v3.1._
625
*/
626
function toInt8(int256 value) internal pure returns (int8) {
627
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
628
return int8(value);
629
}
630
631
/**
632
* @dev Converts an unsigned uint256 into a signed int256.
633
*
634
* Requirements:
635
*
636
* - input must be less than or equal to maxInt256.
637
*/
638
function toInt256(uint256 value) internal pure returns (int256) {
639
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
640
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
641
return int256(value);
642
}
643
}
644
645
// File: @openzeppelin/contracts/utils/math/SignedSafeMath.sol
646
647
648
649
pragma solidity ^0.8.0;
650
651
/**
652
* @dev Wrappers over Solidity's arithmetic operations.
653
*
654
* NOTE: `SignedSafeMath` is no longer needed starting with Solidity 0.8. The compiler
655
* now has built in overflow checking.
656
*/
657
library SignedSafeMath {
658
/**
659
* @dev Returns the multiplication of two signed integers, reverting on
660
* overflow.
661
*
662
* Counterpart to Solidity's `*` operator.
663
*
664
* Requirements:
665
*
666
* - Multiplication cannot overflow.
667
*/
668
function mul(int256 a, int256 b) internal pure returns (int256) {
669
return a * b;
670
}
671
672
/**
673
* @dev Returns the integer division of two signed integers. Reverts on
674
* division by zero. The result is rounded towards zero.
675
*
676
* Counterpart to Solidity's `/` operator.
677
*
678
* Requirements:
679
*
680
* - The divisor cannot be zero.
681
*/
682
function div(int256 a, int256 b) internal pure returns (int256) {
683
return a / b;
684
}
685
686
/**
687
* @dev Returns the subtraction of two signed integers, reverting on
688
* overflow.
689
*
690
* Counterpart to Solidity's `-` operator.
691
*
692
* Requirements:
693
*
694
* - Subtraction cannot overflow.
695
*/
696
function sub(int256 a, int256 b) internal pure returns (int256) {
697
return a - b;
698
}
699
700
/**
701
* @dev Returns the addition of two signed integers, reverting on
702
* overflow.
703
*
704
* Counterpart to Solidity's `+` operator.
705
*
706
* Requirements:
707
*
708
* - Addition cannot overflow.
709
*/
710
function add(int256 a, int256 b) internal pure returns (int256) {
711
return a + b;
712
}
713
}
714
715
// File: @openzeppelin/contracts/utils/math/SafeMath.sol
716
717
718
719
pragma solidity ^0.8.0;
720
721
// CAUTION
722
// This version of SafeMath should only be used with Solidity 0.8 or later,
723
// because it relies on the compiler's built in overflow checks.
724
725
/**
726
* @dev Wrappers over Solidity's arithmetic operations.
727
*
728
* NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
729
* now has built in overflow checking.
730
*/
731
library SafeMath {
732
/**
733
* @dev Returns the addition of two unsigned integers, with an overflow flag.
734
*
735
* _Available since v3.4._
736
*/
737
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
738
unchecked {
739
uint256 c = a + b;
740
if (c < a) return (false, 0);
741
return (true, c);
742
}
743
}
744
745
/**
746
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
747
*
748
* _Available since v3.4._
749
*/
750
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
751
unchecked {
752
if (b > a) return (false, 0);
753
return (true, a - b);
754
}
755
}
756
757
/**
758
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
759
*
760
* _Available since v3.4._
761
*/
762
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
763
unchecked {
764
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
765
// benefit is lost if 'b' is also tested.
766
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
767
if (a == 0) return (true, 0);
768
uint256 c = a * b;
769
if (c / a != b) return (false, 0);
770
return (true, c);
771
}
772
}
773
774
/**
775
* @dev Returns the division of two unsigned integers, with a division by zero flag.
776
*
777
* _Available since v3.4._
778
*/
779
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
780
unchecked {
781
if (b == 0) return (false, 0);
782
return (true, a / b);
783
}
784
}
785
786
/**
787
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
788
*
789
* _Available since v3.4._
790
*/
791
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
792
unchecked {
793
if (b == 0) return (false, 0);
794
return (true, a % b);
795
}
796
}
797
798
/**
799
* @dev Returns the addition of two unsigned integers, reverting on
800
* overflow.
801
*
802
* Counterpart to Solidity's `+` operator.
803
*
804
* Requirements:
805
*
806
* - Addition cannot overflow.
807
*/
808
function add(uint256 a, uint256 b) internal pure returns (uint256) {
809
return a + b;
810
}
811
812
/**
813
* @dev Returns the subtraction of two unsigned integers, reverting on
814
* overflow (when the result is negative).
815
*
816
* Counterpart to Solidity's `-` operator.
817
*
818
* Requirements:
819
*
820
* - Subtraction cannot overflow.
821
*/
822
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
823
return a - b;
824
}
825
826
/**
827
* @dev Returns the multiplication of two unsigned integers, reverting on
828
* overflow.
829
*
830
* Counterpart to Solidity's `*` operator.
831
*
832
* Requirements:
833
*
834
* - Multiplication cannot overflow.
835
*/
836
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
837
return a * b;
838
}
839
840
/**
841
* @dev Returns the integer division of two unsigned integers, reverting on
842
* division by zero. The result is rounded towards zero.
843
*
844
* Counterpart to Solidity's `/` operator.
845
*
846
* Requirements:
847
*
848
* - The divisor cannot be zero.
849
*/
850
function div(uint256 a, uint256 b) internal pure returns (uint256) {
851
return a / b;
852
}
853
854
/**
855
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
856
* reverting when dividing by zero.
857
*
858
* Counterpart to Solidity's `%` operator. This function uses a `revert`
859
* opcode (which leaves remaining gas untouched) while Solidity uses an
860
* invalid opcode to revert (consuming all remaining gas).
861
*
862
* Requirements:
863
*
864
* - The divisor cannot be zero.
865
*/
866
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
867
return a % b;
868
}
869
870
/**
871
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
872
* overflo