$OPUS
Ultimately, secure, fast and transparent fundraising that empowers the right teams will help move the space forward. Canopus is an investor-focused platform that supports rather than confuses members

Whitepaper

Our whitepaper is modified and updated according to business needs.
Whitepaper can be found by visiting #OPUS​

What is the $OPUS contract address?

1
Contract: 0x76076880e1EBBcE597e6E15c47386cd34de4930F
Copied!

Where can I buy and stake the $OPUS?

Check if from this LINK:​

Contract Source Code

1
contract Context {
2
// Empty internal constructor, to prevent people from mistakenly deploying
3
// an instance of this contract, which should be used via inheritance.
4
constructor () internal { }
5
// solhint-disable-previous-line no-empty-blocks
6
​
7
function _msgSender() internal view returns (address payable) {
8
return msg.sender;
9
}
10
​
11
function _msgData() internal view returns (bytes memory) {
12
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
13
return msg.data;
14
}
15
}
16
​
17
interface IERC20 {
18
/**
19
* @dev Returns the amount of tokens in existence.
20
*/
21
function totalSupply() external view returns (uint256);
22
​
23
/**
24
* @dev Returns the amount of tokens owned by `account`.
25
*/
26
function balanceOf(address account) external view returns (uint256);
27
​
28
/**
29
* @dev Moves `amount` tokens from the caller's account to `recipient`.
30
*
31
* Returns a boolean value indicating whether the operation succeeded.
32
*
33
* Emits a {Transfer} event.
34
*/
35
function transfer(address recipient, uint256 amount) external returns (bool);
36
​
37
/**
38
* @dev Returns the remaining number of tokens that `spender` will be
39
* allowed to spend on behalf of `owner` through {transferFrom}. This is
40
* zero by default.
41
*
42
* This value changes when {approve} or {transferFrom} are called.
43
*/
44
function allowance(address owner, address spender) external view returns (uint256);
45
​
46
/**
47
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
48
*
49
* Returns a boolean value indicating whether the operation succeeded.
50
*
51
* IMPORTANT: Beware that changing an allowance with this method brings the risk
52
* that someone may use both the old and the new allowance by unfortunate
53
* transaction ordering. One possible solution to mitigate this race
54
* condition is to first reduce the spender's allowance to 0 and set the
55
* desired value afterwards:
56
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
57
*
58
* Emits an {Approval} event.
59
*/
60
function approve(address spender, uint256 amount) external returns (bool);
61
​
62
/**
63
* @dev Moves `amount` tokens from `sender` to `recipient` using the
64
* allowance mechanism. `amount` is then deducted from the caller's
65
* allowance.
66
*
67
* Returns a boolean value indicating whether the operation succeeded.
68
*
69
* Emits a {Transfer} event.
70
*/
71
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
72
​
73
/**
74
* @dev Emitted when `value` tokens are moved from one account (`from`) to
75
* another (`to`).
76
*
77
* Note that `value` may be zero.
78
*/
79
event Transfer(address indexed from, address indexed to, uint256 value);
80
​
81
/**
82
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
83
* a call to {approve}. `value` is the new allowance.
84
*/
85
event Approval(address indexed owner, address indexed spender, uint256 value);
86
}
87
​
88
library SafeMath {
89
/**
90
* @dev Returns the addition of two unsigned integers, reverting on
91
* overflow.
92
*
93
* Counterpart to Solidity's `+` operator.
94
*
95
* Requirements:
96
* - Addition cannot overflow.
97
*/
98
function add(uint256 a, uint256 b) internal pure returns (uint256) {
99
uint256 c = a + b;
100
require(c >= a, "SafeMath: addition overflow");
101
​
102
return c;
103
}
104
​
105
/**
106
* @dev Returns the subtraction of two unsigned integers, reverting on
107
* overflow (when the result is negative).
108
*
109
* Counterpart to Solidity's `-` operator.
110
*
111
* Requirements:
112
* - Subtraction cannot overflow.
113
*/
114
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
115
return sub(a, b, "SafeMath: subtraction overflow");
116
}
117
​
118
/**
119
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
120
* overflow (when the result is negative).
121
*
122
* Counterpart to Solidity's `-` operator.
123
*
124
* Requirements:
125
* - Subtraction cannot overflow.
126
*
127
* _Available since v2.4.0._
128
*/
129
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
130
require(b <= a, errorMessage);
131
uint256 c = a - b;
132
​
133
return c;
134
}
135
​
136
/**
137
* @dev Returns the multiplication of two unsigned integers, reverting on
138
* overflow.
139
*
140
* Counterpart to Solidity's `*` operator.
141
*
142
* Requirements:
143
* - Multiplication cannot overflow.
144
*/
145
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
146
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
147
// benefit is lost if 'b' is also tested.
148
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
149
if (a == 0) {
150
return 0;
151
}
152
​
153
uint256 c = a * b;
154
require(c / a == b, "SafeMath: multiplication overflow");
155
​
156
return c;
157
}
158
​
159
/**
160
* @dev Returns the integer division of two unsigned integers. Reverts on
161
* division by zero. The result is rounded towards zero.
162
*
163
* Counterpart to Solidity's `/` operator. Note: this function uses a
164
* `revert` opcode (which leaves remaining gas untouched) while Solidity
165
* uses an invalid opcode to revert (consuming all remaining gas).
166
*
167
* Requirements:
168
* - The divisor cannot be zero.
169
*/
170
function div(uint256 a, uint256 b) internal pure returns (uint256) {
171
return div(a, b, "SafeMath: division by zero");
172
}
173
​
174
/**
175
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
176
* division by zero. The result is rounded towards zero.
177
*
178
* Counterpart to Solidity's `/` operator. Note: this function uses a
179
* `revert` opcode (which leaves remaining gas untouched) while Solidity
180
* uses an invalid opcode to revert (consuming all remaining gas).
181
*
182
* Requirements:
183
* - The divisor cannot be zero.
184
*
185
* _Available since v2.4.0._
186
*/
187
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
188
// Solidity only automatically asserts when dividing by 0
189
require(b > 0, errorMessage);
190
uint256 c = a / b;
191
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
192
​
193
return c;
194
}
195
​
196
/**
197
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
198
* Reverts when dividing by zero.
199
*
200
* Counterpart to Solidity's `%` operator. This function uses a `revert`
201
* opcode (which leaves remaining gas untouched) while Solidity uses an
202
* invalid opcode to revert (consuming all remaining gas).
203
*
204
* Requirements:
205
* - The divisor cannot be zero.
206
*/
207
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
208
return mod(a, b, "SafeMath: modulo by zero");
209
}
210
​
211
/**
212
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
213
* Reverts with custom message when dividing by zero.
214
*
215
* Counterpart to Solidity's `%` operator. This function uses a `revert`
216
* opcode (which leaves remaining gas untouched) while Solidity uses an
217
* invalid opcode to revert (consuming all remaining gas).
218
*
219
* Requirements:
220
* - The divisor cannot be zero.
221
*
222
* _Available since v2.4.0._
223
*/
224
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
225
require(b != 0, errorMessage);
226
return a % b;
227
}
228
}
229
​
230
contract ERC20 is Context, IERC20 {
231
using SafeMath for uint256;
232
​
233
mapping (address => uint256) private _balances;
234
​
235
mapping (address => mapping (address => uint256)) private _allowances;
236
​
237
uint256 private _totalSupply;
238
​
239
/**
240
* @dev See {IERC20-totalSupply}.
241
*/
242
function totalSupply() public view returns (uint256) {
243
return _totalSupply;
244
}
245
​
246
/**
247
* @dev See {IERC20-balanceOf}.
248
*/
249
function balanceOf(address account) public view returns (uint256) {
250
return _balances[account];
251
}
252
​
253
/**
254
* @dev See {IERC20-transfer}.
255
*
256
* Requirements:
257
*
258
* - `recipient` cannot be the zero address.
259
* - the caller must have a balance of at least `amount`.
260
*/
261
function transfer(address recipient, uint256 amount) public returns (bool) {
262
_transfer(_msgSender(), recipient, amount);
263
return true;
264
}
265
​
266
/**
267
* @dev See {IERC20-allowance}.
268
*/
269
function allowance(address owner, address spender) public view returns (uint256) {
270
return _allowances[owner][spender];
271
}
272
​
273
/**
274
* @dev See {IERC20-approve}.
275
*
276
* Requirements:
277
*
278
* - `spender` cannot be the zero address.
279
*/
280
function approve(address spender, uint256 amount) public returns (bool) {
281
_approve(_msgSender(), spender, amount);
282
return true;
283
}
284
​
285
/**
286
* @dev See {IERC20-transferFrom}.
287
*
288
* Emits an {Approval} event indicating the updated allowance. This is not
289
* required by the EIP. See the note at the beginning of {ERC20};
290
*
291
* Requirements:
292
* - `sender` and `recipient` cannot be the zero address.
293
* - `sender` must have a balance of at least `amount`.
294
* - the caller must have allowance for `sender`'s tokens of at least
295
* `amount`.
296
*/
297
function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
298
_transfer(sender, recipient, amount);
299
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
300
return true;
301
}
302
​
303
/**
304
* @dev Atomically increases the allowance granted to `spender` by the caller.
305
*
306
* This is an alternative to {approve} that can be used as a mitigation for
307
* problems described in {IERC20-approve}.
308
*
309
* Emits an {Approval} event indicating the updated allowance.
310
*
311
* Requirements:
312
*
313
* - `spender` cannot be the zero address.
314
*/
315
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
316
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
317
return true;
318
}
319
​
320
/**
321
* @dev Atomically decreases the allowance granted to `spender` by the caller.
322
*
323
* This is an alternative to {approve} that can be used as a mitigation for
324
* problems described in {IERC20-approve}.
325
*
326
* Emits an {Approval} event indicating the updated allowance.
327
*
328
* Requirements:
329
*
330
* - `spender` cannot be the zero address.
331
* - `spender` must have allowance for the caller of at least
332
* `subtractedValue`.
333
*/
334
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
335
_approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
336
return true;
337
}
338
​
339
/**
340
* @dev Moves tokens `amount` from `sender` to `recipient`.
341
*
342
* This is internal function is equivalent to {transfer}, and can be used to
343
* e.g. implement automatic token fees, slashing mechanisms, etc.
344
*
345
* Emits a {Transfer} event.
346
*
347
* Requirements:
348
*
349
* - `sender` cannot be the zero address.
350
* - `recipient` cannot be the zero address.
351
* - `sender` must have a balance of at least `amount`.
352
*/
353
function _transfer(address sender, address recipient, uint256 amount) internal {
354
require(sender != address(0), "ERC20: transfer from the zero address");
355
require(recipient != address(0), "ERC20: transfer to the zero address");
356
​
357
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
358
_balances[recipient] = _balances[recipient].add(amount);
359
emit Transfer(sender, recipient, amount);
360
}
361
​
362
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
363
* the total supply.
364
*
365
* Emits a {Transfer} event with `from` set to the zero address.
366
*
367
* Requirements
368
*
369
* - `to` cannot be the zero address.
370
*/
371
function _mint(address account, uint256 amount) internal {
372
require(account != address(0), "ERC20: mint to the zero address");
373
​
374
_totalSupply = _totalSupply.add(amount);
375
_balances[account] = _balances[account].add(amount);
376
emit Transfer(address(0), account, amount);
377
}
378
​
379
/**
380
* @dev Destroys `amount` tokens from `account`, reducing the
381
* total supply.
382
*
383
* Emits a {Transfer} event with `to` set to the zero address.
384
*
385
* Requirements
386
*
387
* - `account` cannot be the zero address.
388
* - `account` must have at least `amount` tokens.
389
*/
390
function _burn(address account, uint256 amount) internal {
391
require(account != address(0), "ERC20: burn from the zero address");
392
​
393
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
394
_totalSupply = _totalSupply.sub(amount);
395
emit Transfer(account, address(0), amount);
396
}
397
​
398
/**
399
* @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
400
*
401
* This is internal function is equivalent to `approve`, and can be used to
402
* e.g. set automatic allowances for certain subsystems, etc.
403
*
404
* Emits an {Approval} event.
405
*
406
* Requirements:
407
*
408
* - `owner` cannot be the zero address.
409
* - `spender` cannot be the zero address.
410
*/
411
function _approve(address owner, address spender, uint256 amount) internal {
412
require(owner != address(0), "ERC20: approve from the zero address");
413
require(spender != address(0), "ERC20: approve to the zero address");
414
​
415
_allowances[owner][spender] = amount;
416
emit Approval(owner, spender, amount);
417
}
418
​
419
/**
420
* @dev Destroys `amount` tokens from `account`.`amount` is then deducted
421
* from the caller's allowance.
422
*
423
* See {_burn} and {_approve}.
424
*/
425
function _burnFrom(address account, uint256 amount) internal {
426
_burn(account, amount);
427
_approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "ERC20: burn amount exceeds allowance"));
428
}
429
}
430
​
431
library Roles {
432
struct Role {
433
mapping (address => bool) bearer;
434
}
435
​
436
/**
437
* @dev Give an account access to this role.
438
*/
439
function add(Role storage role, address account) internal {
440
require(!has(role, account), "Roles: account already has role");
441
role.bearer[account] = true;
442
}
443
​
444
/**
445
* @dev Remove an account's access to this role.
446
*/
447
function remove(Role storage role, address account) internal {
448
require(has(role, account), "Roles: account does not have role");
449
role.bearer[account] = false;
450
}
451
​
452
/**
453
* @dev Check if an account has this role.
454
* @return bool
455
*/
456
function has(Role storage role, address account) internal view returns (bool) {
457
require(account != address(0), "Roles: account is the zero address");
458
return role.bearer[account];
459
}
460
}
461
​
462
contract MinterRole is Context {
463
using Roles for Roles.Role;
464
​
465
event MinterAdded(address indexed account);
466
event MinterRemoved(address indexed account);
467
​
468
Roles.Role private _minters;
469
​
470
constructor () internal {
471
_addMinter(_msgSender());
472
}
473
​
474
modifier onlyMinter() {
475
require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
476
_;
477
}
478
​
479
function isMinter(address account) public view returns (bool) {
480
return _minters.has(account);
481
}
482
​
483
function addMinter(address account) public onlyMinter {
484
_addMinter(account);
485
}
486
​
487
function renounceMinter() public {
488
_removeMinter(_msgSender());
489
}
490
​
491
function _addMinter(address account) internal {
492
_minters.add(account);
493
emit MinterAdded(account);
494
}
495
​
496
function _removeMinter(address account) internal {
497
_minters.remove(account);
498
emit MinterRemoved(account);
499
}
500
}
501
​
502
contract ERC20Mintable is ERC20, MinterRole {
503
/**
504
* @dev See {ERC20-_mint}.
505
*
506
* Requirements:
507
*
508
* - the caller must have the {MinterRole}.
509
*/
510
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
511
_mint(account, amount);
512
return true;
513
}
514
}
515
​
516
contract ERC20Detailed is IERC20 {
517
string private _name;
518
string private _symbol;
519
uint8 private _decimals;
520
​
521
/**
522
* @dev Sets the values for `name`, `symbol`, and `decimals`. All three of
523
* these values are immutable: they can only be set once during
524
* construction.
525
*/
526
constructor (string memory name, string memory symbol, uint8 decimals) public {
527
_name = name;
528
_symbol = symbol;
529
_decimals = decimals;
530
}
531
​
532
/**
533
* @dev Returns the name of the token.
534
*/
535
function name() public view returns (string memory) {
536
return _name;
537
}
538
​
539
/**
540
* @dev Returns the symbol of the token, usually a shorter version of the
541
* name.
542
*/
543
function symbol() public view returns (string memory) {
544
return _symbol;
545
}
546
​
547
/**
548
* @dev Returns the number of decimals used to get its user representation.
549
* For example, if `decimals` equals `2`, a balance of `505` tokens should
550
* be displayed to a user as `5,05` (`505 / 10 ** 2`).
551
*
552
* Tokens usually opt for a value of 18, imitating the relationship between
553
* Ether and Wei.
554
*
555
* NOTE: This information is only used for _display_ purposes: it in
556
* no way affects any of the arithmetic of the contract, including
557
* {IERC20-balanceOf} and {IERC20-transfer}.
558
*/
559
function decimals() public view returns (uint8) {
560
return _decimals;
561
}
562
}
563
​
564
contract Canopus is ERC20Mintable, ERC20Detailed{
565
string public constant NAME = "Canopus";
566
string public constant SYMBOL = "OPUS";
567
uint8 public constant DECIMALS = 18;
568
uint256 public constant INITIAL_SUPPLY = 1000000000 * (10 ** uint256(DECIMALS));
569
​
570
uint256 mintLockTime;
571
uint256 deployedDate;
572
​
573
event LocktimeExteded(uint256 extendedBy, uint256 deadline);
574
​
575
constructor()
576
ERC20Detailed(NAME, SYMBOL, DECIMALS) public
577
{
578
deployedDate = now;
579
_mint(msg.sender, INITIAL_SUPPLY);
580
}
581
​
582
function mint(address account, uint256 amount) public onlyMinter returns (bool) {
583
if (now < SafeMath.add(deployedDate, mintLockTime)) {
584
return false;
585
}
586
_mint(account, amount);
587
return true;
588
}
589
​
590
function extendMintLockTime(uint256 _extraLockTime) public onlyMinter {
591
mintLockTime = SafeMath.add(mintLockTime, _extraLockTime);
592
​
593
emit LocktimeExteded(_extraLockTime, deployedDate + mintLockTime);
594
}
595
}
Copied!

Additional information about Canopus Network

For additional information feel free to refer to our White Paper.
If you still have any questions or issues, feel free to reach the Canopus team in the telegram group.
​