Contract Name:
XaurumToken
Contract Source Code:
File 1 of 1 : XaurumToken
contract ERC20TokenInterface {
/// @return total amount of tokens
function totalSupply() constant returns (uint256 supply) {}
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance) {}
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success) {}
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
/// @notice `msg.sender` approves `_addr` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of wei to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success) {}
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract XaurumProxyERC20 is ERC20TokenInterface {
bool public xaurumProxyWorking;
XaurumToken xaurumTokenReference;
address proxyCurrator;
address owner;
address dev;
/* Public variables of the token */
string public standard = 'XaurumERCProxy';
string public name = 'Xaurum';
string public symbol = 'XAUR';
uint8 public decimals = 8;
modifier isWorking(){
if (xaurumProxyWorking && !xaurumTokenReference.lockdown()){
_
}
}
function XaurumProxyERC20(){
dev = msg.sender;
xaurumProxyWorking = true;
}
function setTokenReference(address _xaurumTokenAress) returns (bool){
if (msg.sender == proxyCurrator){
xaurumTokenReference = XaurumToken(_xaurumTokenAress);
return true;
}
return false;
}
function EnableDisableTokenProxy() returns (bool){
if (msg.sender == proxyCurrator){
xaurumProxyWorking = !xaurumProxyWorking;
return true;
}
return false;
}
function setProxyCurrator(address _newCurratorAdress) returns (bool){
if (msg.sender == owner || msg.sender == dev){
proxyCurrator = _newCurratorAdress;
return true;
}
return false;
}
function setOwner(address _newOwnerAdress) returns (bool){
if ( msg.sender == dev ){
owner = _newOwnerAdress;
return true;
}
return false;
}
function totalSupply() constant returns (uint256 supply) {
return xaurumTokenReference.totalSupply();
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return xaurumTokenReference.balanceOf(_owner);
}
function transfer(address _to, uint256 _value) isWorking returns (bool success) {
bool answerStatus;
address sentFrom;
address sentTo;
uint256 sentToAmount;
address burningAddress;
uint256 burningAmount;
(answerStatus, sentFrom, sentTo, sentToAmount, burningAddress, burningAmount) = xaurumTokenReference.transferViaProxy(msg.sender, _to, _value);
if(answerStatus){
Transfer(sentFrom, sentTo, sentToAmount);
Transfer(sentFrom, burningAddress, burningAmount);
return true;
}
return false;
}
function transferFrom(address _from, address _to, uint256 _value) isWorking returns (bool success) {
bool answerStatus;
address sentFrom;
address sentTo;
uint256 sentToAmount;
address burningAddress;
uint256 burningAmount;
(answerStatus, sentFrom, sentTo, sentToAmount, burningAddress, burningAmount) = xaurumTokenReference.transferFromViaProxy(msg.sender, _from, _to, _value);
if(answerStatus){
Transfer(sentFrom, sentTo, sentToAmount);
Transfer(sentFrom, burningAddress, burningAmount);
return true;
}
return false;
}
function approve(address _spender, uint256 _value) isWorking returns (bool success) {
if (xaurumTokenReference.approveFromProxy(msg.sender, _spender, _value)){
Approval(msg.sender, _spender, _value);
return true;
}
return false;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return xaurumTokenReference.allowanceFromProxy(msg.sender, _owner, _spender);
}
}
contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); }
contract XaurumToken {
/* Public variables of the token */
string public standard = 'Xaurum v1.0';
string public name = 'Xaurum';
string public symbol = 'XAUR';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
uint256 public totalGoldSupply = 0;
bool public lockdown = false;
uint256 numberOfCoinages;
/* Private variabiles for the token */
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => uint) lockedAccounts;
/* Events */
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Burn(address from, uint256 value, BurningType burningType);
event Melt(uint256 xaurAmount, uint256 goldAmount);
event Coinage(uint256 coinageId, uint256 usdAmount, uint256 xaurAmount, uint256 goldAmount, uint256 totalGoldSupply, uint256 totalSupply);
/*enums*/
enum BurningType { TxtFee, AllyDonation, ServiceFee }
/* Contracts */
XaurumMeltingContract public meltingContract;
function setMeltingContract(address _meltingContractAddress){
if (msg.sender == owner || msg.sender == dev){
meltingContract = XaurumMeltingContract(_meltingContractAddress);
}
}
XaurumDataContract public dataContract;
function setDataContract(address _dataContractAddress){
if (msg.sender == owner || msg.sender == dev){
dataContract = XaurumDataContract(_dataContractAddress);
}
}
XaurumCoinageContract public coinageContract;
function setCoinageContract(address _coinageContractAddress){
if (msg.sender == owner || msg.sender == dev){
coinageContract = XaurumCoinageContract(_coinageContractAddress);
}
}
XaurmProxyContract public proxyContract;
function setProxyContract(address _proxyContractAddress){
if (msg.sender == owner || msg.sender == dev){
proxyContract = XaurmProxyContract(_proxyContractAddress);
}
}
XaurumAlliesContract public alliesContract;
function setAlliesContract(address _alliesContractAddress){
if (msg.sender == owner || msg.sender == dev){
alliesContract = XaurumAlliesContract(_alliesContractAddress);
}
}
/* owner */
address public owner;
function setOwner(address _newOwnerAdress) returns (bool){
if ( msg.sender == dev ){
owner = _newOwnerAdress;
return true;
}
return false;
}
address public dev;
/* Xaur for gas */
address xaurForGasCurrator;
function setXauForGasCurrator(address _curratorAddress){
if (msg.sender == owner || msg.sender == dev){
xaurForGasCurrator = _curratorAddress;
}
}
/* Burrning */
address public burningAdress;
/* Constructor */
function XaurumToken(address _burningAddress) {
burningAdress = _burningAddress;
lockdown = false;
dev = msg.sender;
// initial
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 5999319593600000;
totalSupply += 5999319593600000;
totalGoldSupply += 1696620000000;
Coinage(numberOfCoinages, 0, 5999319593600000, 1696620000000, totalGoldSupply, totalSupply);
// Mint 1
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 1588947591000000;
totalSupply += 1588947591000000;
totalGoldSupply += 1106042126000;
Coinage(numberOfCoinages, 60611110000000, 1588947591000000, 1106042126000, totalGoldSupply, totalSupply);
// Mint 2
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 151127191000000;
totalSupply += 151127191000000;
totalGoldSupply += 110134338200;
Coinage(numberOfCoinages, 6035361000000, 151127191000000, 110134338200, totalGoldSupply, totalSupply);
// Mint 3
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 63789854418800;
totalSupply += 63789854418800;
totalGoldSupply += 46701000000;
Coinage(numberOfCoinages, 2559215000000, 63789854418800, 46701000000, totalGoldSupply, totalSupply);
// Mint 4
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 393015011191000;
totalSupply += 393015011191000;
totalGoldSupply += 290692000000;
Coinage(numberOfCoinages, 15929931000000, 393015011191000, 290692000000, totalGoldSupply, totalSupply);
// Mint 5
numberOfCoinages += 1;
balances[0x097B7b672fe0dc3eF61f53B954B3DCC86382e7B9] += 49394793870000;
totalSupply += 49394793870000;
totalGoldSupply += 36891368614;
Coinage(numberOfCoinages, 2021647000000, 49394793870000, 36891368614, totalGoldSupply, totalSupply);
}
function freezeCoin(){
if (msg.sender == owner || msg.sender == dev){
lockdown = !lockdown;
}
}
/* Get balance of the account */
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
/* Send coins */
function transfer(address _to, uint256 _amount) returns (bool status) {
uint256 goldFee = dataContract.goldFee();
if (balances[msg.sender] >= _amount && // Check if the sender has enough
balances[_to] + _amount > balances[_to] && // Check for overflows
_amount > goldFee && // Check if there is something left after burning fee
!lockdown && // Check if coin is on lockdown
lockedAccounts[msg.sender] <= block.number) { // Check if the account is locked
balances[msg.sender] -= _amount; // Subtract from the sender minus the fee
balances[_to] += (_amount - goldFee ); // Add the same to the recipient
Transfer(msg.sender, _to, (_amount - goldFee )); // Notify anyone listening that this transfer took place
doBurn(msg.sender, goldFee, BurningType.TxtFee); // Notify anyone listening that this burn took place
return true;
} else {
return false;
}
}
/* A contract attempts to get the coins and sends them*/
function transferFrom(address _from, address _to, uint256 _amount) returns (bool status) {
uint256 goldFee = dataContract.goldFee();
if (balances[_from] >= _amount && // Check if the sender has enough
balances[_to] + _amount > balances[_to] && // Check for overflows
_amount > goldFee && // Check if there is something left after burning fee
!lockdown && // Check if coin is on lockdown
lockedAccounts[_from] <= block.number) { // Check if the account is locked
if (_amount > allowed[_from][msg.sender]){ // Check allowance
return false;
}
balances[_from] -= _amount; // Subtract from the sender minus the fee
balances[_to] += (_amount - goldFee); // Add the same to the recipient
Transfer(_from, _to, (_amount - goldFee)); // Notify anyone listening that this transfer took place
doBurn(_from, goldFee, BurningType.TxtFee);
allowed[_from][msg.sender] -= _amount; // Update allowance
return true;
} else {
return false;
}
}
/* Allow another contract to spend some tokens in your behalf */
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
returns (bool success) {
allowed[msg.sender][_spender] = _value;
tokenRecipient spender = tokenRecipient(_spender);
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/* Send coins via proxy */
function transferViaProxy(address _source, address _to, uint256 _amount) returns (bool status, address sendFrom, address sentTo, uint256 sentToAmount, address burnAddress, uint256 burnAmount){
if (!proxyContract.isProxyLegit(msg.sender)){ // Check if proxy is legit
return (false, 0, 0, 0, 0, 0);
}
uint256 goldFee = dataContract.goldFee();
if (balances[_source] >= _amount && // Check if the sender has enough
balances[_to] + _amount > balances[_to] && // Check for overflows
_amount > goldFee && // Check if there is something left after burning fee
!lockdown && // Check if coin is on lockdown
lockedAccounts[_source] <= block.number) { // Check if the account is locked
balances[_source] -= _amount; // Subtract from the sender minus the fee
balances[_to] += (_amount - goldFee ); // Add the same to the recipient
Transfer(_source, _to, ( _amount - goldFee )); // Notify anyone listening that this transfer took place
doBurn(_source, goldFee, BurningType.TxtFee); // Notify anyone listening that this burn took place
return (true, _source, _to, (_amount - goldFee), burningAdress, goldFee);
} else {
return (false, 0, 0, 0, 0, 0);
}
}
/* a contract attempts to get the coins and sends them via proxy */
function transferFromViaProxy(address _source, address _from, address _to, uint256 _amount) returns (bool status, address sendFrom, address sentTo, uint256 sentToAmount, address burnAddress, uint256 burnAmount) {
if (!proxyContract.isProxyLegit(msg.sender)){ // Check if proxy is legit
return (false, 0, 0, 0, 0, 0);
}
uint256 goldFee = dataContract.goldFee();
if (balances[_from] >= _amount && // Check if the sender has enough
balances[_to] + _amount > balances[_to] && // Check for overflows
_amount > goldFee && // Check if there is something left after burning fee
!lockdown && // Check if coin is on lockdown
lockedAccounts[_from] <= block.number) { // Check if the account is locked
if (_amount > allowed[_from][_source]){ // Check allowance
return (false, 0, 0, 0, 0, 0);
}
balances[_from] -= _amount; // Subtract from the sender minus the fee
balances[_to] += ( _amount - goldFee ); // Add the same to the recipient
Transfer(_from, _to, ( _amount - goldFee )); // Notify anyone listening that this transfer took place
doBurn(_from, goldFee, BurningType.TxtFee);
allowed[_from][_source] -= _amount; // Update allowance
return (true, _from, _to, (_amount - goldFee), burningAdress, goldFee);
} else {
return (false, 0, 0, 0, 0, 0);
}
}
function approveFromProxy(address _source, address _spender, uint256 _value) returns (bool success) {
if (!proxyContract.isProxyLegit(msg.sender)){ // Check if proxy is legit
return false;
}
allowed[_source][_spender] = _value;
Approval(_source, _spender, _value);
return true;
}
function allowanceFromProxy(address _source, address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
/* -----------------------------------------------------------------------*/
/* Lock account for X amount of blocks */
function lockAccount(uint _block) returns (bool answer){
if (lockedAccounts[msg.sender] < block.number + _block){
lockedAccounts[msg.sender] = block.number + _block;
return true;
}
return false;
}
function isAccountLocked(address _accountAddress) returns (bool){
if (lockedAccounts[_accountAddress] > block.number){
return true;
}
return false;
}
///
/// Xaur for gas region
///
/* user get small amout of wei for a small amout of Xaur */
function getGasForXau(address _to) returns (bool sucess){
uint256 xaurForGasLimit = dataContract.xaurForGasLimit();
uint256 weiForXau = dataContract.weiForXau();
if (balances[msg.sender] > xaurForGasLimit &&
balances[xaurForGasCurrator] < balances[xaurForGasCurrator] + xaurForGasLimit &&
this.balance > dataContract.weiForXau()) {
if (_to.send(dataContract.weiForXau())){
balances[msg.sender] -= xaurForGasLimit;
balances[xaurForGasCurrator] += xaurForGasLimit;
return true;
}
}
return false;
}
/* Currator fills eth through this function */
function fillGas(){
if (msg.sender != xaurForGasCurrator) {
throw;
}
}
///
/// Melting region
///
function doMelt(uint256 _xaurAmount, uint256 _goldAmount) returns (bool){
if (msg.sender == address(meltingContract)){
totalSupply -= _xaurAmount;
totalGoldSupply -= _goldAmount;
Melt(_xaurAmount, _goldAmount);
return true;
}
return false;
}
///
/// Proxy region
///
///
/// Coinage region
///
function doCoinage(address[] _coinageAddresses, uint256[] _coinageAmounts, uint256 _usdAmount, uint256 _xaurCoined, uint256 _goldBought) returns (bool){
if (msg.sender == address(coinageContract) &&
_coinageAddresses.length == _coinageAmounts.length){
totalSupply += _xaurCoined;
totalGoldSupply += _goldBought;
numberOfCoinages += 1;
Coinage(numberOfCoinages, _usdAmount, _xaurCoined, _goldBought, totalGoldSupply, totalSupply);
for (uint256 cnt = 0; cnt < _coinageAddresses.length; cnt++){
balances[_coinageAddresses[cnt]] += _coinageAmounts[cnt];
}
return true;
}
return false;
}
///
/// Burining region
///
function doBurn(address _from, uint256 _amountToBurn, BurningType _burningType) internal {
balances[burningAdress] += _amountToBurn; // Burn the fee
totalSupply -= _amountToBurn; // Edit total supply
Burn(_from, _amountToBurn, _burningType); // Notify anyone listening that this burn took place
}
function doBurnFromContract(address _from, uint256 _amount) returns (bool){
if (msg.sender == address(alliesContract)){
balances[_from] -= _amount;
doBurn(_from, _amount, BurningType.AllyDonation);
return true;
}
else if(msg.sender == address(coinageContract)){
balances[_from] -= _amount;
doBurn(_from, _amount, BurningType.ServiceFee);
return true;
}
else{
return false;
}
}
/* This unnamed function is called whenever someone tries to send ether to it */
function () {
throw; // Prevents accidental sending of ether
}
}
contract XaurumMeltingContract {}
contract XaurumAlliesContract {}
contract XaurumCoinageContract {}
contract XaurmProxyContract{
address public owner;
address public curator;
address public dev;
function XaurmProxyContract(){
dev = msg.sender;
}
function setProxyCurrator(address _newCurratorAdress) returns (bool){
if (msg.sender == owner || msg.sender == dev){
curator = _newCurratorAdress;
return true;
}
return false;
}
function setOwner(address _newOwnerAdress) returns (bool){
if ( msg.sender == dev ){
owner = _newOwnerAdress;
return true;
}
return false;
}
/* Proxy Contract */
address[] approvedProxys;
mapping (address => bool) proxyList;
/* Adds new proxy to proxy lists and grants him the permission to use transferViaProxy */
function addNewProxy(address _proxyAdress){
if(msg.sender == curator){
proxyList[_proxyAdress] = true;
approvedProxys.push(_proxyAdress);
}
}
function isProxyLegit(address _proxyAddress) returns (bool){
return proxyList[_proxyAddress];
}
function getApprovedProxys() returns (address[] proxys){
return approvedProxys;
}
function () {
throw;
}
}
contract XaurumDataContract {
/* Minting data */
uint256 public xauToEur;
uint256 public goldToEur;
uint256 public mintingDataUpdatedAtBlock;
/* Gas for xaur data */
uint256 public xaurForGasLimit;
uint256 public weiForXau;
uint256 public gasForXaurDataUpdateAtBlock;
/* Other data */
uint256 public goldFee;
uint256 public goldFeeDataUpdatedAtBlock;
address public owner;
address public curator;
address public dev;
function XaurumDataContract(){
xaurForGasLimit = 100000000;
weiForXau = 100000000000000000;
goldFee = 50000000;
// dev = _dev;
dev = msg.sender;
}
function setProxyCurrator(address _newCurratorAdress) returns (bool){
if (msg.sender == owner || msg.sender == dev){
curator = _newCurratorAdress;
return true;
}
return false;
}
function setOwner(address _newOwnerAdress) returns (bool){
if ( msg.sender == dev ){
owner = _newOwnerAdress;
return true;
}
return false;
}
function updateMintingData(uint256 _xauToEur, uint256 _goldToEur) returns (bool status){
if (msg.sender == curator || msg.sender == dev){
xauToEur = _xauToEur;
goldToEur = _goldToEur;
mintingDataUpdatedAtBlock = block.number;
return true;
}
return false;
}
function updateGasForXaurData(uint256 _xaurForGasLimit, uint256 _weiForXau) returns (bool status){
if (msg.sender == curator || msg.sender == dev){
xaurForGasLimit = _xaurForGasLimit;
weiForXau = _weiForXau;
gasForXaurDataUpdateAtBlock = block.number;
return true;
}
return false;
}
function updateGoldFeeData(uint256 _goldFee) returns (bool status){
if (msg.sender == curator || msg.sender == dev){
goldFee = _goldFee;
goldFeeDataUpdatedAtBlock = block.number;
return true;
}
return false;
}
function () {
throw;
}
}