LIQ Token Contracts
Fully Audited: All smart contracts used by Liquidus are fully audited by reputational auditing companies.
The utility token LIQ is deployed natively on BNB Smart Chain. It is also present on Ethereum, Polygon, and Cronos via the Multichain bridge protocol.
Blockchain | Contract |
|---|---|
BNB Smart Chain | 0xc7981767f644c7f8e483dabdc413e8a371b83079 |
Ethereum | 0x5F69b7Ab8F7cAb199a310Fd5A27B43Fef44ddcC0 |
Polygon | 0x4036f3d9c45a20f44f0b8B85dD6CA33005fF9654 |
Cronos | 0xabd380327fe66724ffda91a87c772fb8d00be488 |
The following code is the native LIQ token contract. The LIQ tokens deployed by Multichain are based on the AnyswapV5ERC20 smart contract.
1
pragma solidity ^0.8.4;
2
3
/**
4
LIQUIDUS
5
*/
6
7
interface IBEP20 {
8
9
/**
10
* @dev Moves `amount` tokens from the caller's account to `recipient`.
11
*
12
* Returns a boolean value indicating whether the operation succeeded.
13
*
14
* Emits a {Transfer} event.
15
*/
16
function transfer(address recipient, uint256 amount) external returns (bool);
17
18
/**
19
* @dev Returns the remaining number of tokens that `spender` will be
20
* allowed to spend on behalf of `owner` through {transferFrom}. This is
21
* zero by default.
22
*
23
* This value changes when {approve} or {transferFrom} are called.
24
*/
25
function allowance(address _owner, address spender) external view returns (uint256);
26
27
/**
28
* @dev Emitted when `value` tokens are moved from one account (`from`) to
29
* another (`to`).
30
*
31
* Note that `value` may be zero.
32
*/
33
event Transfer(address indexed from, address indexed to, uint256 value);
34
35
/**
36
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
37
* a call to {approve}. `value` is the new allowance.
38
*/
39
event Approval(address indexed owner, address indexed spender, uint256 value);
40
}
41
42
/**
43
* @dev Wrappers over Solidity's arithmetic operations with added overflow
44
* checks.
45
*
46
* Arithmetic operations in Solidity wrap on overflow. This can easily result
47
* in bugs, because programmers usually assume that an overflow raises an
48
* error, which is the standard behavior in high level programming languages.
49
* `SafeMath` restores this intuition by reverting the transaction when an
50
* operation overflows.
51
*
52
* Using this library instead of the unchecked operations eliminates an entire
53
* class of bugs, so it's recommended to use it always.
54
*/
55
library SafeMath {
56
/**
57
* @dev Returns the addition of two unsigned integers, reverting on
58
* overflow.
59
*
60
* Counterpart to Solidity's `+` operator.
61
*
62
* Requirements:
63
* - Addition cannot overflow.
64
*/
65
function add(uint256 a, uint256 b) internal pure returns (uint256) {
66
uint256 c = a + b;
67
require(c >= a, "SafeMath: addition overflow");
68
69
return c;
70
}
71
72
/**
73
* @dev Returns the subtraction of two unsigned integers, reverting on
74
* overflow (when the result is negative).
75
*
76
* Counterpart to Solidity's `-` operator.
77
*
78
* Requirements:
79
* - Subtraction cannot overflow.
80
*/
81
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
82
return sub(a, b, "SafeMath: subtraction overflow");
83
}
84
85
/**
86
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
87
* overflow (when the result is negative).
88
*
89
* Counterpart to Solidity's `-` operator.
90
*
91
* Requirements:
92
* - Subtraction cannot overflow.
93
*/
94
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
95
require(b <= a, errorMessage);
96
uint256 c = a - b;
97
98
return c;
99
}
100
101
/**
102
* @dev Returns the multiplication of two unsigned integers, reverting on
103
* overflow.
104
*
105
* Counterpart to Solidity's `*` operator.
106
*
107
* Requirements:
108
* - Multiplication cannot overflow.
109
*/
110
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
111
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
112
// benefit is lost if 'b' is also tested.
113
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
114
if (a == 0) {
115
return 0;
116
}
117
118
uint256 c = a * b;
119
require(c / a == b, "SafeMath: multiplication overflow");
120
121
return c;
122
}
123
124
/**
125
* @dev Returns the integer division of two unsigned integers. Reverts on
126
* division by zero. The result is rounded towards zero.
127
*
128
* Counterpart to Solidity's `/` operator. Note: this function uses a
129
* `revert` opcode (which leaves remaining gas untouched) while Solidity
130
* uses an invalid opcode to revert (consuming all remaining gas).
131
*
132
* Requirements:
133
* - The divisor cannot be zero.
134
*/
135
function div(uint256 a, uint256 b) internal pure returns (uint256) {
136
return div(a, b, "SafeMath: division by zero");
137
}
138
139
/**
140
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
141
* division by zero. The result is rounded towards zero.
142
*
143
* Counterpart to Solidity's `/` operator. Note: this function uses a
144
* `revert` opcode (which leaves remaining gas untouched) while Solidity
145
* uses an invalid opcode to revert (consuming all remaining gas).
146
*
147
* Requirements:
148
* - The divisor cannot be zero.
149
*/
150
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
151
// Solidity only automatically asserts when dividing by 0
152
require(b > 0, errorMessage);
153
uint256 c = a / b;
154
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
155
156
return c;
157
}
158
159
/**
160
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
161
* Reverts when dividing by zero.
162
*
163
* Counterpart to Solidity's `%` operator. This function uses a `revert`
164
* opcode (which leaves remaining gas untouched) while Solidity uses an
165
* invalid opcode to revert (consuming all remaining gas).
166
*
167
* Requirements:
168
* - The divisor cannot be zero.
169
*/
170
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
171
return mod(a, b, "SafeMath: modulo by zero");
172
}
173
174
/**
175
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
176
* Reverts with custom message when dividing by zero.
177
*
178
* Counterpart to Solidity's `%` operator. This function uses a `revert`
179
* opcode (which leaves remaining gas untouched) while Solidity uses an
180
* invalid opcode to revert (consuming all remaining gas).
181
*
182
* Requirements:
183
* - The divisor cannot be zero.
184
*/
185
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
186
require(b != 0, errorMessage);
187
return a % b;
188
}
189
}
190
191
/*
192
* @dev Provides information about the current execution context, including the
193
* sender of the transaction and its data. While these are generally available
194
* via msg.sender and msg.data, they should not be accessed in such a direct
195
* manner, since when dealing with GSN meta-transactions the account sending and
196
* paying for execution may not be the actual sender (as far as an application
197
* is concerned).
198
*
199
* This contract is only required for intermediate, library-like contracts.
200
*/
201
abstract contract Context {
202
function _msgSender() internal view virtual returns (address) {
203
return msg.sender;
204
}
205
206
function _msgData() internal view virtual returns (bytes calldata) {
207
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
208
return msg.data;
209
}
210
}
211
212
/**
213
* @dev Contract module which provides a basic access control mechanism, where
214
* there is an account (an owner) that can be granted exclusive access to
215
* specific functions.
216
*
217
* By default, the owner account will be the one that deploys the contract. This
218
* can later be changed with {transferOwnership}.
219
*
220
* This module is used through inheritance. It will make available the modifier
221
* `onlyOwner`, which can be applied to your functions to restrict their use to
222
* the owner.
223
*/
224
contract Ownable is Context {
225
address private _owner;
226
227
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
228
229
/**
230
* @dev Initializes the contract setting the deployer as the initial owner.
231
*/
232
constructor () {address msgSender = _msgSender();
233
_owner = msgSender;
234
emit OwnershipTransferred(address(0), msgSender);
235
}
236
237
/**
238
* @dev Returns the address of the current owner.
239
*/
240
function owner() public view returns (address) {
241
return _owner;
242
}
243
244
/**
245
* @dev Throws if called by any account other than the owner.
246
*/
247
modifier onlyOwner() {
248
require(_owner == _msgSender(), "Ownable: caller is not the owner");
249
_;
250
}
251
252
/**
253
* @dev Leaves the contract without owner. It will not be possible to call
254
* `onlyOwner` functions anymore. Can only be called by the current owner.
255
*
256
* NOTE: Renouncing ownership will leave the contract without an owner,
257
* thereby removing any functionality that is only available to the owner.
258
*/
259
function renounceOwnership() public onlyOwner {
260
emit OwnershipTransferred(_owner, address(0));
261
_owner = address(0);
262
}
263
264
/**
265
* @dev Transfers ownership of the contract to a new account (`newOwner`).
266
* Can only be called by the current owner.
267
*/
268
function transferOwnership(address newOwner) public onlyOwner {
269
_transferOwnership(newOwner);
270
}
271
272
/**
273
* @dev Transfers ownership of the contract to a new account (`newOwner`).
274
*/
275
function _transferOwnership(address newOwner) internal {
276
require(newOwner != address(0), "Ownable: new owner is the zero address");
277
emit OwnershipTransferred(_owner, newOwner);
278
_owner = newOwner;
279
}
280
}
281
282
contract Liquidus is Context, IBEP20, Ownable {
283
using SafeMath for uint256;
284
285
mapping (address => uint256) private _balances;
286
287
mapping (address => mapping (address => uint256)) private _allowances;
288
289
uint256 private _totalSupply;
290
uint8 private _decimals;
291
string private _symbol;
292
string private _name;
293
294
constructor() {
295
_name = "Liquidus";
296
_symbol = "LIQ";
297
_decimals = 18;
298
_totalSupply = 1 * 10**8 * 10**18; //100m tokens
299
_balances[msg.sender] = _totalSupply;
300
emit Transfer(address(0), msg.sender, _totalSupply);
301
}
302
303
/**
304
* @dev Returns the bep token owner.
305
*/
306
function getOwner() external view returns (address) {return owner();}
307
308
/**
309
* @dev Returns the token decimals.
310
*/
311
function decimals() external view returns (uint8) {return _decimals;}
312
313
/**
314
* @dev Returns the token symbol.
315
*/
316
function symbol() external view returns (string memory) { return _symbol;}
317
318
/**
319
* @dev Returns the token name.
320
*/
321
function name() external view returns (string memory) {return _name;
322
}
323
324
/**
325
* @dev See {BEP20-totalSupply}.
326
*/
327
function totalSupply() external view returns (uint256) {return _totalSupply;
328
}
329
330
/**
331
* @dev See {BEP20-balanceOf}.
332
*/
333
function balanceOf(address account) external view returns (uint256) {
334
return _balances[account];
335
}
336
337
/**
338
* @dev See {BEP20-transfer}.
339
*
340
* Requirements:
341
*
342
* - `recipient` cannot be the zero address.
343
* - the caller must have a balance of at least `amount`.
344
*/
345
function transfer(address recipient, uint256 amount) external override returns (bool) {
346
_transfer(_msgSender(), recipient, amount);
347
return true;
348
}
349
350
/**
351
* @dev See {BEP20-allowance}.
352
*/
353
function allowance(address owner, address spender) external view override returns (uint256) {
354
return _allowances[owner][spender];
355
}
356
357
/**
358
* @dev See {BEP20-approve}.
359
*
360
* Requirements:
361
*
362
* Returns a boolean value indicating whether the operation succeeded.
363
*
364
* IMPORTANT: Beware that changing an allowance with this method brings the risk
365
* that someone may use both the old and the new allowance by unfortunate
366
* transaction ordering. One possible solution to mitigate this race
367
* condition is to first reduce the spender's allowance to 0 and set the
368
* desired value afterwards:
369
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
370
*
371
* Emits an {Approval} event.
372
*
373
* - `spender` cannot be the zero address.
374
*/
375
function approve(address spender, uint256 amount) external returns (bool) {
376
_approve(_msgSender(), spender, amount);
377
return true;
378
}
379
380
/**
381
* @dev See {BEP20-transferFrom}.
382
*
383
* Emits an {Approval} event indicating the updated allowance. This is not
384
* required by the EIP. See the note at the beginning of {BEP20};
385
*
386
* Requirements:
387
* - `sender` and `recipient` cannot be the zero address.
388
* - `sender` must have a balance of at least `amount`.
389
* - the caller must have allowance for `sender`'s tokens of at least
390
* `amount`.
391
*/
392
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
393
_transfer(sender, recipient, amount);
394
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: transfer amount exceeds allowance"));
395
return true;
396
}
397
398
/**
399
* @dev Atomically increases the allowance granted to `spender` by the caller.
400
*
401
* This is an alternative to {approve} that can be used as a mitigation for
402
* problems described in {BEP20-approve}.
403
*
404
* Emits an {Approval} event indicating the updated allowance.
405
*
406
* Requirements:
407
*
408
* - `spender` cannot be the zero address.
409
*/
410
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
411
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
412
return true;
413
}
414
415
/**
416
* @dev Atomically decreases the allowance granted to `spender` by the caller.
417
*
418
* This is an alternative to {approve} that can be used as a mitigation for
419
* problems described in {BEP20-approve}.
420
*
421
* Emits an {Approval} event indicating the updated allowance.
422
*
423
* Requirements:
424
*
425
* - `spender` cannot be the zero address.
426
* - `spender` must have allowance for the caller of at least
427
* `subtractedValue`.
428
*/
429
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
430
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero"));
431
return true;
432
}
433
434
/**
435
* @dev Destroys `amount` tokens from the caller.
436
*
437
* See {BEP20-_burn}.
438
*/
439
function burn(uint256 amount) public virtual {
440
_burn(_msgSender(), amount);
441
}
442
443
/**
444
* @dev Destroys `amount` tokens from `account`, deducting from the caller's
445
* allowance.
446
*
447
* See {BEP20-_burn} and {BEP20-allowance}.
448
*
449
* Requirements:
450
*
451
* - the caller must have allowance for ``accounts``'s tokens of at least
452
* `amount`.
453
*/
454
function burnFrom(address account, uint256 amount) public virtual {
455
uint256 decreasedAllowance =
456
_allowances[account][_msgSender()].sub(
457
amount,
458
'BEP20: burn amount exceeds allowance'
459
);
460
461
_approve(account, _msgSender(), decreasedAllowance);
462
_burn(account, amount);
463
}
464
465
/**
466
* @dev Moves tokens `amount` from `sender` to `recipient`.
467
*
468
* This is internal function is equivalent to {transfer}, and can be used to
469
* e.g. implement automatic token fees, slashing mechanisms, etc.
470
*
471
* Emits a {Transfer} event.
472
*
473
* Requirements:
474
*
475
* - `sender` cannot be the zero address.
476
* - `recipient` cannot be the zero address.
477
* - `sender` must have a balance of at least `amount`.
478
*/
479
function _transfer(address sender, address recipient, uint256 amount) internal {
480
require(sender != address(0), "BEP20: transfer from the zero address");
481
require(recipient != address(0), "BEP20: transfer to the zero address");
482
483
_balances[sender] = _balances[sender].sub(amount, "BEP20: transfer amount exceeds balance");
484
_balances[recipient] = _balances[recipient].add(amount);
485
emit Transfer(sender, recipient, amount);
486
}
487
488
489
/**
490
* @dev Destroys `amount` tokens from `account`, reducing the
491
* total supply.
492
*
493
* Emits a {Transfer} event with `to` set to the zero address.
494
*
495
* Requirements
496
*
497
* - `account` cannot be the zero address.
498
* - `account` must have at least `amount` tokens.
499
*/
500
function _burn(address account, uint256 amount) internal {
501
require(account != address(0), "BEP20: burn from the zero address");
502
503
_balances[account] = _balances[account].sub(amount, "BEP20: burn amount exceeds balance");
504
_totalSupply = _totalSupply.sub(amount);
505
emit Transfer(account, address(0), amount);
506
}
507
508
/**
509
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
510
*
511
* This is internal function is equivalent to `approve`, and can be used to
512
* e.g. set automatic allowances for certain subsystems, etc.
513
*
514
* Emits an {Approval} event.
515
*
516
* Requirements:
517
*
518
* - `owner` cannot be the zero address.
519
* - `spender` cannot be the zero address.
520
*/
521
function _approve(address owner, address spender, uint256 amount) internal {
522
require(owner != address(0), "BEP20: approve from the zero address");
523
require(spender != address(0), "BEP20: approve to the zero address");
524
525
_allowances[owner][spender] = amount;
526
emit Approval(owner, spender, amount);
527
}
528
}
Last modified 1mo ago