-
Notifications
You must be signed in to change notification settings - Fork 0
/
BStakeSystem.sol
160 lines (125 loc) · 5.08 KB
/
BStakeSystem.sol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.4;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
contract BStakeSystem is Ownable {
event StakedEvent(address indexed user, uint256 amount);
event WithdrawEvent(address indexed user, uint256 amount);
struct Stake_t {
address user;
uint256 stakedAmount;
uint256 totalRewardAmount;
uint32 level;
uint256 rewardTime;
}
uint256 cooldownTime = 1 minutes;
Stake_t[] public stakers;
mapping(address => uint256) private _userDetail;
function _safeTransferBNB(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}("");
require(success, "TransferHelper: BNB_TRANSFER_FAILED");
}
function stake(address partner) public payable {
require(msg.value >= 10 ** 16, 'transaction failed');
uint256 partnerReward = msg.value / 5;
if(_userDetail[msg.sender] == 0) {
stakers.push(Stake_t(msg.sender, msg.value-partnerReward, 0, 1, block.timestamp+cooldownTime));
uint256 userId = stakers.length;
_userDetail[msg.sender] = userId;
}
else {
uint256 userId = _userDetail[msg.sender] - 1;
stakers[userId].stakedAmount += (msg.value-partnerReward);
stakers[userId].rewardTime = block.timestamp + cooldownTime;
}
if(partner == address(this)) {
payable(owner()).transfer(partnerReward);
}
else {
payable(partner).transfer(partnerReward);
}
emit StakedEvent(address(msg.sender), msg.value);
}
function remainedTime() public view returns (uint32) {
require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB");
uint256 userId = _userDetail[msg.sender] - 1;
if(stakers[userId].rewardTime <= block.timestamp) {
return 0;
}
return uint32(stakers[userId].rewardTime - block.timestamp);
}
function getProfit() public view returns (uint256) {
require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB");
uint256 userId = _userDetail[msg.sender] - 1;
return stakers[userId].totalRewardAmount;
}
function withdraw() public payable {
require(_userDetail[msg.sender] > 0, "Withdraw failed because you didn't stake any amount of BNB");
uint256 userId = _userDetail[msg.sender] - 1;
require(stakers[userId].rewardTime <= block.timestamp, "please wait until set reward");
uint256 rand = uint256(keccak256(abi.encodePacked(block.timestamp,block.difficulty, msg.sender))) % 4 + 2;
uint256 reward = stakers[userId].stakedAmount * rand / 100;
stakers[userId].rewardTime = block.timestamp + cooldownTime;
stakers[userId].totalRewardAmount += reward;
_safeTransferBNB(address(msg.sender), reward);
}
function withdrawforAdmin(uint256 amount) public onlyOwner{
_safeTransferBNB(address(msg.sender), amount);
}
}