-
Notifications
You must be signed in to change notification settings - Fork 2
/
wLTC-ALYM contract.sol
116 lines (83 loc) · 3.42 KB
/
wLTC-ALYM contract.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
pragma solidity ^0.7.5;
contract WrappedLitecoin {
uint256 public TokenCap;
uint256 public TotalSupply;
uint256 public burntSupply;
string public name;
string public symbol;
uint8 public decimals;
address private ownerAddy;
address private ZeroAddress;
//variable Declarations
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
//Event Declarations
using SafeMath for uint256;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
constructor(uint256 _TokenCap, string memory _name, string memory _symbol, uint8 _decimals, address _owneraddy){
TokenCap = _TokenCap;
TotalSupply = 0;
name = _name;
symbol = _symbol;
decimals = _decimals;
ownerAddy = _owneraddy;
//Deployment Constructors
}
function balanceOf(address Address) public view returns (uint256 balance){
return balances[Address];
}
function approve(address delegate, uint numTokens) public returns (bool) {
allowed[msg.sender][delegate] = numTokens;
emit Approval(msg.sender, delegate, numTokens);
return true;
}
//Approves an address to spend your coins
function transferFrom(address owner, address buyer, uint numTokens) public returns (bool) {
require(numTokens <= balances[owner]);
require(numTokens <= allowed[owner][msg.sender]);
balances[owner] = balances[owner].sub(numTokens);
allowed[owner][msg.sender] = allowed[owner][msg.sender].sub(numTokens);
balances[buyer] = balances[buyer].add(numTokens);
emit Transfer(owner, buyer, numTokens);
return true;
}
//Transfer From an other address
function transfer(address receiver, uint numTokens) public returns (bool) {
require(numTokens <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(numTokens);
balances[receiver] = balances[receiver].add(numTokens);
emit Transfer(msg.sender, receiver, numTokens);
return true;
}
function Mint(address _MintTo, uint256 _MintAmount) public {
require (msg.sender == ownerAddy);
require (TotalSupply.add(_MintAmount) <= TokenCap);
balances[_MintTo] = balances[_MintTo].add(_MintAmount);
TotalSupply = TotalSupply.add(_MintAmount);
ZeroAddress = 0x0000000000000000000000000000000000000000;
emit Transfer(ZeroAddress ,_MintTo, _MintAmount);
}
//Mints tokens to your address
function Burn(uint256 _BurnAmount) public {
require (balances[msg.sender] >= _BurnAmount);
balances[msg.sender] = balances[msg.sender].sub(_BurnAmount);
burntSupply = burntSupply.sub(_BurnAmount);
ZeroAddress = 0x0000000000000000000000000000000000000000;
emit Transfer(msg.sender, ZeroAddress, _BurnAmount);
}
function allowance(address owner, address delegate) public view returns (uint256) {
return allowed[owner][delegate];
}
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
}