Single Token Farm Contracts

Fully Audited: All smart contracts used by Liquidus are fully audited by reputational auditing companies.

Liquidus Farm Contracts

Start farming LIQ tokens now on farm.liquidus.finance

Single Token Farms

Farm
Blockchain
Contract
Lock Duration
LIQ - 1 Month
BNB Smart Chain
N/A
1 Month
LIQ - 3 Months
BNB Smart Chain
0x03c5D2Cf0b79822eDB2B60d9F5aF290Facf190DD
3 Months
LIQ - 6 Months
BNB Smart Chain
0x7b00f1084B0C70089e569c41451E34E477ecb184
6 Months
LIQ - 12 Months
BNB Smart Chain
0x89c0e71A3109311aD82ea786a76c074Ef82e91d7
12 Months
LIQ - 3 Months
Cronos
0xB67640F6D742d35650F95E4C0294670E8824adaa
3 Months

Smart Contract Code

1
// File: @openzeppelin/contracts/utils/Context.sol
2
3
pragma solidity >=0.6.0 <0.8.0;
4
5
/* use 0.6.12 compiler version
6
* @dev Provides information about the current execution context, including the
7
* sender of the transaction and its data. While these are generally available
8
* via msg.sender and msg.data, they should not be accessed in such a direct
9
* manner, since when dealing with GSN meta-transactions the account sending and
10
* paying for execution may not be the actual sender (as far as an application
11
* is concerned).
12
*
13
* This contract is only required for intermediate, library-like contracts.
14
*/
15
abstract contract Context {
16
function _msgSender() internal view virtual returns (address payable) {
17
return msg.sender;
18
}
19
20
function _msgData() internal view virtual returns (bytes memory) {
21
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
22
return msg.data;
23
}
24
}
25
26
// File: @openzeppelin/contracts/access/Ownable.sol
27
28
pragma solidity >=0.6.0 <0.8.0;
29
30
/**
31
* @dev Contract module which provides a basic access control mechanism, where
32
* there is an account (an owner) that can be granted exclusive access to
33
* specific functions.
34
*
35
* By default, the owner account will be the one that deploys the contract. This
36
* can later be changed with {transferOwnership}.
37
*
38
* This module is used through inheritance. It will make available the modifier
39
* `onlyOwner`, which can be applied to your functions to restrict their use to
40
* the owner.
41
*/
42
abstract contract Ownable is Context {
43
address private _owner;
44
45
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
46
47
/**
48
* @dev Initializes the contract setting the deployer as the initial owner.
49
*/
50
constructor() internal {
51
address msgSender = _msgSender();
52
_owner = msgSender;
53
emit OwnershipTransferred(address(0), msgSender);
54
}
55
56
/**
57
* @dev Returns the address of the current owner.
58
*/
59
function owner() public view virtual returns (address) {
60
return _owner;
61
}
62
63
/**
64
* @dev Throws if called by any account other than the owner.
65
*/
66
modifier onlyOwner() {
67
require(owner() == _msgSender(), "Ownable: caller is not the owner");
68
_;
69
}
70
71
/**
72
* @dev Leaves the contract without owner. It will not be possible to call
73
* `onlyOwner` functions anymore. Can only be called by the current owner.
74
*
75
* NOTE: Renouncing ownership will leave the contract without an owner,
76
* thereby removing any functionality that is only available to the owner.
77
*/
78
function renounceOwnership() public virtual onlyOwner {
79
emit OwnershipTransferred(_owner, address(0));
80
_owner = address(0);
81
}
82
83
/**
84
* @dev Transfers ownership of the contract to a new account (`newOwner`).
85
* Can only be called by the current owner.
86
*/
87
function transferOwnership(address newOwner) public virtual onlyOwner {
88
require(newOwner != address(0), "Ownable: new owner is the zero address");
89
emit OwnershipTransferred(_owner, newOwner);
90
_owner = newOwner;
91
}
92
}
93
94
// File: @openzeppelin/contracts/math/SafeMath.sol
95
96
pragma solidity >=0.6.0 <0.8.0;
97
98
/**
99
* @dev Wrappers over Solidity's arithmetic operations with added overflow
100
* checks.
101
*
102
* Arithmetic operations in Solidity wrap on overflow. This can easily result
103
* in bugs, because programmers usually assume that an overflow raises an
104
* error, which is the standard behavior in high level programming languages.
105
* `SafeMath` restores this intuition by reverting the transaction when an
106
* operation overflows.
107
*
108
* Using this library instead of the unchecked operations eliminates an entire
109
* class of bugs, so it's recommended to use it always.
110
*/
111
library SafeMath {
112
/**
113
* @dev Returns the addition of two unsigned integers, with an overflow flag.
114
*
115
* _Available since v3.4._
116
*/
117
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
118
uint256 c = a + b;
119
if (c < a) return (false, 0);
120
return (true, c);
121
}
122
123
/**
124
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
125
*
126
* _Available since v3.4._
127
*/
128
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
129
if (b > a) return (false, 0);
130
return (true, a - b);
131
}
132
133
/**
134
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
135
*
136
* _Available since v3.4._
137
*/
138
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
139
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
140
// benefit is lost if 'b' is also tested.
141
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
142
if (a == 0) return (true, 0);
143
uint256 c = a * b;
144
if (c / a != b) return (false, 0);
145
return (true, c);
146
}
147
148
/**
149
* @dev Returns the division of two unsigned integers, with a division by zero flag.
150
*
151
* _Available since v3.4._
152
*/
153
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
154
if (b == 0) return (false, 0);
155
return (true, a / b);
156
}
157
158
/**
159
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
160
*
161
* _Available since v3.4._
162
*/
163
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
164
if (b == 0) return (false, 0);
165
return (true, a % b);
166
}
167
168
/**
169
* @dev Returns the addition of two unsigned integers, reverting on
170
* overflow.
171
*
172
* Counterpart to Solidity's `+` operator.
173
*
174
* Requirements:
175
*
176
* - Addition cannot overflow.
177
*/
178
function add(uint256 a, uint256 b) internal pure returns (uint256) {
179
uint256 c = a + b;
180
require(c >= a, "SafeMath: addition overflow");
181
return c;
182
}
183
184
/**
185
* @dev Returns the subtraction of two unsigned integers, reverting on
186
* overflow (when the result is negative).
187
*
188
* Counterpart to Solidity's `-` operator.
189
*
190
* Requirements:
191
*
192
* - Subtraction cannot overflow.
193
*/
194
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
195
require(b <= a, "SafeMath: subtraction overflow");
196
return a - b;
197
}
198
199
/**
200
* @dev Returns the multiplication of two unsigned integers, reverting on
201
* overflow.
202
*
203
* Counterpart to Solidity's `*` operator.
204
*
205
* Requirements:
206
*
207
* - Multiplication cannot overflow.
208
*/
209
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
210
if (a == 0) return 0;
211
uint256 c = a * b;
212
require(c / a == b, "SafeMath: multiplication overflow");
213
return c;
214
}
215
216
/**
217
* @dev Returns the integer division of two unsigned integers, reverting on
218
* division by zero. The result is rounded towards zero.
219
*
220
* Counterpart to Solidity's `/` operator. Note: this function uses a
221
* `revert` opcode (which leaves remaining gas untouched) while Solidity
222
* uses an invalid opcode to revert (consuming all remaining gas).
223
*
224
* Requirements:
225
*
226
* - The divisor cannot be zero.
227
*/
228
function div(uint256 a, uint256 b) internal pure returns (uint256) {
229
require(b > 0, "SafeMath: division by zero");
230
return a / b;
231
}
232
233
/**
234
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
235
* reverting when dividing by zero.
236
*
237
* Counterpart to Solidity's `%` operator. This function uses a `revert`
238
* opcode (which leaves remaining gas untouched) while Solidity uses an
239
* invalid opcode to revert (consuming all remaining gas).
240
*
241
* Requirements:
242
*
243
* - The divisor cannot be zero.
244
*/
245
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
246
require(b > 0, "SafeMath: modulo by zero");
247
return a % b;
248
}
249
250
/**
251
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
252
* overflow (when the result is negative).
253
*
254
* CAUTION: This function is deprecated because it requires allocating memory for the error
255
* message unnecessarily. For custom revert reasons use {trySub}.
256
*
257
* Counterpart to Solidity's `-` operator.
258
*
259
* Requirements:
260
*
261
* - Subtraction cannot overflow.
262
*/
263
function sub(
264
uint256 a,
265
uint256 b,
266
string memory errorMessage
267
) internal pure returns (uint256) {
268
require(b <= a, errorMessage);
269
return a - b;
270
}
271
272
/**
273
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
274
* division by zero. The result is rounded towards zero.
275
*
276
* CAUTION: This function is deprecated because it requires allocating memory for the error
277
* message unnecessarily. For custom revert reasons use {tryDiv}.
278
*
279
* Counterpart to Solidity's `/` operator. Note: this function uses a
280
* `revert` opcode (which leaves remaining gas untouched) while Solidity
281
* uses an invalid opcode to revert (consuming all remaining gas).
282
*
283
* Requirements:
284
*
285
* - The divisor cannot be zero.
286
*/
287
function div(
288
uint256 a,
289
uint256 b,
290
string memory errorMessage
291
) internal pure returns (uint256) {
292
require(b > 0, errorMessage);
293
return a / b;
294
}
295
296
/**
297
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
298
* reverting with custom message when dividing by zero.
299
*
300
* CAUTION: This function is deprecated because it requires allocating memory for the error
301
* message unnecessarily. For custom revert reasons use {tryMod}.
302
*
303
* Counterpart to Solidity's `%` operator. This function uses a `revert`
304
* opcode (which leaves remaining gas untouched) while Solidity uses an
305
* invalid opcode to revert (consuming all remaining gas).
306
*
307
* Requirements:
308
*
309
* - The divisor cannot be zero.
310
*/
311
function mod(
312
uint256 a,
313
uint256 b,
314
string memory errorMessage
315
) internal pure returns (uint256) {
316
require(b > 0, errorMessage);
317
return a % b;
318
}
319
}
320
321
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol
322
323
pragma solidity >=0.6.0 <0.8.0;
324
325
/**
326
* @dev Contract module that helps prevent reentrant calls to a function.
327
*
328
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
329
* available, which can be applied to functions to make sure there are no nested
330
* (reentrant) calls to them.
331
*
332
* Note that because there is a single `nonReentrant` guard, functions marked as
333
* `nonReentrant` may not call one another. This can be worked around by making
334
* those functions `private`, and then adding `external` `nonReentrant` entry
335
* points to them.
336
*
337
* TIP: If you would like to learn more about reentrancy and alternative ways
338
* to protect against it, check out our blog post
339
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
340
*/
341
abstract contract ReentrancyGuard {
342
// Booleans are more expensive than uint256 or any type that takes up a full
343
// word because each write operation emits an extra SLOAD to first read the
344
// slot's contents, replace the bits taken up by the boolean, and then write
345
// back. This is the compiler's defense against contract upgrades and
346
// pointer aliasing, and it cannot be disabled.
347
348
// The values being non-zero value makes deployment a bit more expensive,
349
// but in exchange the refund on every call to nonReentrant will be lower in
350
// amount. Since refunds are capped to a percentage of the total
351
// transaction's gas, it is best to keep them low in cases like this one, to
352
// increase the likelihood of the full refund coming into effect.
353
uint256 private constant _NOT_ENTERED = 1;
354
uint256 private constant _ENTERED = 2;
355
356
uint256 private _status;
357
358
constructor() internal {
359
_status = _NOT_ENTERED;
360
}
361
362
/**
363
* @dev Prevents a contract from calling itself, directly or indirectly.
364
* Calling a `nonReentrant` function from another `nonReentrant`
365
* function is not supported. It is possible to prevent this from happening
366
* by making the `nonReentrant` function external, and make it call a
367
* `private` function that does the actual work.
368
*/
369
modifier nonReentrant() {
370
// On the first call to nonReentrant, _notEntered will be true
371
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
372
373
// Any calls to nonReentrant after this point will fail
374
_status = _ENTERED;
375
376
_;
377
378
// By storing the original value once again, a refund is triggered (see
379
// https://eips.ethereum.org/EIPS/eip-2200)
380
_status = _NOT_ENTERED;
381
}
382
}
383
384
// File: bsc-library/contracts/IBEP20.sol
385
386
pragma solidity >=0.4.0;
387
388
interface IBEP20 {
389
/**
390
* @dev Returns the amount of tokens in existence.
391
*/
392
function totalSupply() external view returns (uint256);
393
394
/**
395
* @dev Returns the token decimals.
396
*/
397
function decimals() external view returns (uint8);
398
399
/**
400
* @dev Returns the token symbol.
401
*/
402
function symbol() external view returns (string memory);
403
404
/**
405
* @dev Returns the token name.
406
*/
407
function name() external view returns (string memory);
408
409
/**
410
* @dev Returns the bep token owner.
411
*/
412
function getOwner() external view returns (address);
413
414
/**
415
* @dev Returns the amount of tokens owned by `account`.
416
*/
417
function balanceOf(address account) external view returns (uint256);
418
419
/**
420
* @dev Moves `amount` tokens from the caller's account to `recipient`.
421
*
422
* Returns a boolean value indicating whether the operation succeeded.
423
*
424
* Emits a {Transfer} event.
425
*/
426
function transfer(address recipient, uint256 amount) external returns (bool);
427
428
/**
429
* @dev Returns the remaining number of tokens that `spender` will be
430
* allowed to spend on behalf of `owner` through {transferFrom}. This is
431
* zero by default.
432
*
433
* This value changes when {approve} or {transferFrom} are called.
434
*/
435
function allowance(address _owner, address spender) external view returns (uint256);
436
437
/**
438
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
439
*
440
* Returns a boolean value indicating whether the operation succeeded.
441
*
442
* IMPORTANT: Beware that changing an allowance with this method brings the risk
443
* that someone may use both the old and the new allowance by unfortunate
444
* transaction ordering. One possible solution to mitigate this race
445
* condition is to first reduce the spender's allowance to 0 and set the
446
* desired value afterwards:
447
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
448
*
449
* Emits an {Approval} event.
450
*/
451
function approve(address spender, uint256 amount) external returns (bool);
452
453
/**
454
* @dev Moves `amount` tokens from `sender` to `recipient` using the
455
* allowance mechanism. `amount` is then deducted from the caller's
456
* allowance.
457
*
458
* Returns a boolean value indicating whether the operation succeeded.
459
*
460
* Emits a {Transfer} event.
461
*/
462
function transferFrom(
463
address sender,
464
address recipient,
465
uint256 amount
466
) external returns (bool);
467
468
/**
469
* @dev Emitted when `value` tokens are moved from one account (`from`) to
470
* another (`to`).
471
*
472
* Note that `value` may be zero.
473
*/
474
event Transfer(address indexed from, address indexed to, uint256 value);
475
476
/**
477
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
478
* a call to {approve}. `value` is the new allowance.
479
*/
480
event Approval(address indexed owner, address indexed spender, uint256 value);
481
}
482
483
// File: @openzeppelin/contracts/utils/Address.sol
484
485
pragma solidity >=0.6.2 <0.8.0;
486
487
/**
488
* @dev Collection of functions related to the address type
489
*/
490
library Address {
491
/**
492
* @dev Returns true if `account` is a contract.
493
*
494
* [IMPORTANT]
495
* ====
496
* It is unsafe to assume that an address for which this function returns
497
* false is an externally-owned account (EOA) and not a contract.
498
*
499
* Among others, `isContract` will return false for the following
500
* types of addresses:
501
*
502
* - an externally-owned account
503
* - a contract in construction
504
* - an address where a contract will be created
505
* - an address where a contract lived, but was destroyed
506
* ====
507
*/
508
function isContract(address account) internal view returns (bool) {
509
// This method relies on extcodesize, which returns 0 for contracts in
510
// construction, since the code is only stored at the end of the
511
// constructor execution.
512
513
uint256 size;
514
// solhint-disable-next-line no-inline-assembly
515
assembly {
516
size := extcodesize(account)
517
}
518
return size > 0;
519
}
520
521
/**
522
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
523
* `recipient`, forwarding all available gas and reverting on errors.
524
*
525
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
526
* of certain opcodes, possibly making contracts go over the 2300 gas limit
527
* imposed by `transfer`, making them unable to receive funds via
528
* `transfer`. {sendValue} removes this limitation.
529
*
530
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
531
*
532
* IMPORTANT: because control is transferred to `recipient`, care must be
533
* taken to not create reentrancy vulnerabilities. Consider using
534
* {ReentrancyGuard} or the
535
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
536
*/
537
function sendValue(address payable recipient, uint256 amount) internal {
538
require(address(this).balance >= amount, "Address: insufficient balance");
539
540
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
541
(bool success, ) = recipient.call{value: amount}("");
542
require(success, "Address: unable to send value, recipient may have reverted");
543
}
544
545
/**
546
* @dev Performs a Solidity function call using a low level `call`. A
547
* plain`call` is an unsafe replacement for a function call: use this
548
* function instead.
549
*
550
* If `target` reverts with a revert reason, it is bubbled up by this
551
* function (like regular Solidity function calls).
552
*
553
* Returns the raw returned data. To convert to the expected return value,
554
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
555
*
556
* Requirements:
557
*
558
* - `target` must be a contract.
559
* - calling `target` with `data` must not revert.
560
*
561
* _Available since v3.1._
562
*/
563
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
564
return functionCall(target, data, "Address: low-level call failed");
565
}
566
567
/**
568
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
569
* `errorMessage` as a fallback revert reason when `target` reverts.
570
*
571
* _Available since v3.1._
572
*/
573
function functionCall(
574
address target,
575
bytes memory data,
576
string memory errorMessage
577
) internal returns (bytes memory) {
578
return functionCallWithValue(target, data, 0, errorMessage);
579
}
580
581
/**
582
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
583
* but also transferring `value` wei to `target`.
584
*
585
* Requirements:
586
*
587
* - the calling contract must have an ETH balance of at least `value`.
588
* - the called Solidity function must be `payable`.
589
*
590
* _Available since v3.1._
591
*/
592
function functionCallWithValue(
593
address target,
594
bytes memory data,
595
uint256 value
596
) internal returns (bytes memory) {
597
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
598
}
599
600
/**
601
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
602
* with `errorMessage` as a fallback revert reason when `target` reverts.
603
*
604
* _Available since v3.1._
605
*/
606
function functionCallWithValue(
607
address target,
608
bytes memory data,
609
uint256 value,
610
string memory errorMessage
611
) internal returns (bytes memory) {
612
require(address(this).balance >= value, "Address: insufficient balance for call");
613
require(isContract(target), "Address: call to non-contract");
614
615
// solhint-disable-next-line avoid-low-level-calls
616
(bool success, bytes memory returndata) = target.call{value: value}(data);
617
return _verifyCallResult(success, returndata, errorMessage);
618
}
619
620
/**
621
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
622
* but performing a static call.
623
*
624
* _Available since v3.3._
625
*/
626
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
627
return functionStaticCall(target, data, "Address: low-level static call failed");
628
}
629
630
/**
631
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
632
* but performing a static call.
633
*
634
* _Available since v3.3._
635
*/
636
function functionStaticCall(
637
address target,
638
bytes memory data,
639
string memory errorMessage
640
) internal view returns (bytes memory) {
641
require(isContract(target), "Address: static call to non-contract");
642
643
// solhint-disable-next-line avoid-low-level-calls
644
(bool success, bytes memory returndata) = target.staticcall(data);
645
return _verifyCallResult(success, returndata, errorMessage);
646
}
647
648
/**
649
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
650
* but performing a delegate call.
651
*
652
* _Available since v3.4._
653
*/
654
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
655
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
656
}
657
658
/**
659
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
660
* but performing a delegate call.
661
*
662
* _Available since v3.4._
663
*/
664
function functionDelegateCall(
665
address target,
666
bytes memory data,
667
string memory errorMessage
668
) internal returns (bytes memory) {
669
require(isContract(target), "Address: delegate call to non-contract");
670
671
// solhint-disable-next-line avoid-low-level-calls
672
(bool success, bytes memory returndata) = target.delegatecall(data);
673
return _verifyCallResult(success, returndata, errorMessage);
674
}
675
676
function _verifyCallResult(
677
bool success,
678
bytes memory returndata,
679
string memory errorMessage
680
) private pure returns (bytes memory) {
681
if (success) {
682
return returndata;
683
} else {
684
// Look for revert reason and bubble it up if present
685
if (returndata.length > 0) {
686
// The easiest way to bubble the revert reason is using memory via assembly
687
688
// solhint-disable-next-line no-inline-assembly
689
assembly {
690
let returndata_size := mload(returndata)
691
revert(add(32, returndata), returndata_size)
692
}
693
} else {
694
revert(errorMessage);
695
}
696
}
697
}
698
}
699
700
// File: bsc-library/contracts/SafeBEP20.sol
701
702
pragma solidity ^0.6.0;
703
704
/**
705
* @title SafeBEP20
706
* @dev Wrappers around BEP20 operations that throw on failure (when the token
707
* contract returns false). Tokens that return no value (and instead revert or
708
* throw on failure) are also supported, non-reverting calls are assumed to be
709
* successful.
710
* To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract,
711
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
712
*/
713
library SafeBEP20 {
714
using SafeMath for uint256;
715
using Address for address;
716
717
function safeTransfer(
718
IBEP20 token,
719
address to,
720
uint256 value
721
) internal {
722
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
723
}
724
725
function safeTransferFrom(
726
IBEP20 token,
727
address from,
728
address to,
729
uint256 value
730
) internal {
731
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
732
}
733
734
/**
735
* @dev Deprecated. This function has issues similar to the ones found in
736
* {IBEP20-approve}, and its usage is discouraged.
737
*
738
* Whenever possible, use {safeIncreaseAllowance} and
739
* {safeDecreaseAllowance} instead.
740
*/
741
function safeApprove(
742
IBEP20 token,
743
address spender,
744
uint256 value
745
) internal {
746
// safeApprove should only be called when setting an initial allowance,
747
// or when resetting it to zero. To increase and decrease it, use
748
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
749
// solhint-disable-next-line max-line-length
750
require(
751
(value == 0) || (token.allowance(address(this), spender) == 0),
752
"SafeBEP20: approve from non-zero to non-zero allowance"
753
);
754
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
755
}
756
757
function safeIncreaseAllowance(
758
IBEP20 token,
759
address spender,
760
uint256 value
761
) internal {
762
uint256 newAllowance = token.allowance(address(this), spender).add(value);
763
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
764
}
765
766
function safeDecreaseAllowance(
767
IBEP20 token,
768
address spender,
769
uint256 value
770
) internal {
771
uint256 newAllowance =
772
token.allowance(address(this), spender).sub(value, "SafeBEP20: decreased allowance below zero");
773
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
774
}
775
776
/**
777
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
778
* on the return value: the return value is optional (but if data is returned, it must not be false).
779
* @param token The token targeted by the call.
780
* @param data The call data (encoded using abi.encode or one of its variants).
781
*/
782
function _callOptionalReturn(IBEP20 token, bytes memory data) private {
783
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
784
// we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
785
// the target address contains contract code and also asserts for success in the low-level call.
786
787
bytes memory returndata = address(token).functionCall(data, "SafeBEP20: low-level call failed");
788
if (returndata.length > 0) {
789
// Return data is optional
790
// solhint-disable-next-line max-line-length
791
require(abi.decode(returndata, (bool)), "SafeBEP20: BEP20 operation did not succeed");
792
}
793
}
794
}
795
796
// File: contracts/SmartChefInitializable.sol
797
798
pragma solidity 0.6.12;
799
800
contract CodiStake is Ownable, ReentrancyGuard {
801
using SafeMath for uint256;
802
using SafeBEP20 for IBEP20;
803
804
// Accrued token per share
805
uint256 public accTokenPerShare;
806
807
// The block number when mining ends.
808
uint256 public bonusEndBlock;
809
810
// The block number when mining starts.
811
uint256 public startBlock;
812
813
// The block number of the last pool update
814
uint256 public lastRewardBlock;
815
816
// tokens created per block.
817
uint256 public rewardPerBlock;
818
819
// The precision factor
820
uint256 public PRECISION_FACTOR;
821
822
// The staked & reward token same
823
IBEP20 public stakedToken;
824
825
uint256 public stakedTokenSupply;
826
uint256 public rewardTokenSupplyRemaining;
827
828
uint256 public vestingTime;
829
// Info of each user that stakes tokens (stakedToken)
830
mapping(address => UserInfo) public userInfo;
831
832
struct UserInfo {
833
uint256 amount; // How many staked tokens the user has provided
834
uint256 rewardDebt; // Reward debt
835
uint256 lastDepositedAt;
836
}
837
838
event AdminTokenRecovery(address tokenRecovered, uint256 amount);
839
event Deposit(address indexed user, uint256 amount);
840
event EmergencyWithdraw(address indexed user, uint256 amount);
841
event NewStartAndEndBlocks(uint256 startBlock, uint256 endBlock);
842
event NewRewardPerBlock(uint256 rewardPerBlock);
843
event RewardsStop(uint256 blockNumber);
844
event Withdraw(address indexed user, uint256 amount);
845
846
constructor() public {
847
stakedToken = IBEP20(0xc7981767f644C7F8e483DAbDc413e8a371b83079);
848
rewardPerBlock = 10**18 / 100; // 0.01 token per block
849
startBlock = block.number;
850
bonusEndBlock = block.number.add(10512000); // One year
851
852
PRECISION_FACTOR = uint256(10**12);
853
854
lastRewardBlock = startBlock;
855
}
856
857
/*
858
* @notice Deposit staked tokens and collect reward tokens (if any)