[ANN][ICO] AUTORIA: Best Currency with Automated Mining, Claim Your Mining Well

[me1507]

Dev, I'm a little bit confusing, why did you use Primalbase avatar and signature, while you have your own ICO ?
You should use your own, not promoting others

[1714004574]

1714004574

[1714004574]

1714004574

[1714004574]

1714004574

[1714004574]

1714004574

[1714004574]

1714004574

[1714004574]

1714004574

[techtrader250]

Buy AUT if you want to get autism.

[bigcash2011]

I think it is great concept, Ico investors can make some passive income for just holding these tokens, the only concern that comes up is that the release and sale of the mined coins will keep decreasing the token value, is it true?

[MaxMuze]

This smells awfully scammy. There is nothing here anyone should be paying for via an ICO. Minereum distributed their tokens for free...

You aim to raise 5700 ETH, worth $1.8million at today's price... what for?

[Voltaje]

30% for the Devs and just one year to reach full supply seems to be a little weird. But I'll keep an eye on this token.

Please review our whitepaper. These tokens will be used in probably fair games, payment of bounty, and investor bonuses upon reaching specific milestones.

I've read the whitepaper, and it appears to me that this is only another ICO with the difference that instead of getting the tokens right away, you get them slowly within a year, and it doesn't get whales away, the more you invest, the more tokens you produce, 1 ETH of investment will get you a Well of about 17500 AUT, wich I wouldn't be able to trade right away, but bit by bit, that would be good for a predictable distribution, but only for one year, after that, this is only a token with a pre-mined supply, Minereum is generated automatically in a lapse of 47 years, wich make the token rare, and more valuable; one last think, i the whitepaper mention that the initial wells will be continue mining forever, meaning that the supply will go on forever too, so I will be receiving 17500 tokens a year forever, or the one having a well of 40 ETH will get 700000 a year forever too, so is this 70 millions of increase supply a year? o how much do each well mine AFTER the pre mining process?

[ekoja]

Guys be aware..This guy is Alex Kampa the serial scammer who started sikoba project and scammed people.
Don't get scammed by him again.

Serial scammer! Oops, damn him!

[autoria]

Guys be aware..This guy is Alex Kampa the serial scammer who started sikoba project and scammed people.
Don't get scammed by him again.

Serial scammer! Oops, damn him!

Hi ekoja, we are not aware of anybody by this name and have never heard of the sikoba project. Sorry.

[Alert guy]

This project is a scam project by Mexican scammer(Alex Campa), any money invested in this project should be considered as donation.

Filthy Motherfucker scammer...pic

[ProspectorsPR]

This project is a scam project by Mexican scammer(Alex Campa), any money invested in this project should be considered as donation.

Filthy Motherfucker scammer...pic

https://s4.postimg.org/jfjm12am5/Screenshot_149.png

OH MY GOD  so the developer is Alex kampa the serial scammer? why he wants to scam us, has he got no real jobs to do instead sitting behind internet and jerking off and ripping off people with their valuables.

[smokim87]

Guys be aware..This guy is Alex Kampa the serial scammer who started sikoba project and scammed people.
Don't get scammed by him again.

Serial scammer! Oops, damn him!

I honestly though this was Dave Wilkinson aka Benbtc ( Zeth, Alenium, scrypt waves...etc)


Copies Minerium, starts an ICO for it...

Unfucken believable the nerve people have clones shit and begs for money.

You ain't getting shit...fucken guy asking leg accounts to post their announcement...there's a reason newbie accounts can't so they dont flash thir outsourced design and template of a site to people...

[TimeTeller]

Hey guys, AUT dev here.

First, we asked a trusted member of BCT to post our ANN because our account is unable to embed images.

Second,
Minereum does exist, but the implementation is pretty piss poor. Here's their code:
https://github.com/minereum/Minereum/blob/master/minereum.sol
-snip-

The original Minereum contract is literally just some dude copying and pasting the addresses people bought into a solidity contract and giving them tokens they can't access for a while.

With Autoria, it's closer to proof of stake. So the more coins you invest in initially, the more you can pull from your 'aquifer.' Also, the ICO is on the blockchain, where Minereum was at the discretion of the creator copying and pasting addresses into the contract. Details are in the whitepaper.

I'll do a video comparing the two in a bit.

Let's see who's gonna win at the end then.
It's okay to have a competition because this will create the best from them.
It's not new in crypto that there's some kind of similarity or copycat, but their execution will be different.
So it's up to the supporters if they will be loyal or not, or continue to support them or leave them.
Anyway, it's their effort, time & money that are being at stake here.

[J@soN]

Is this a copy cat of minereum?

And... is your legendary account legit? I know people can buy Legendary accounts here in the forum.

Careful for scams people!

Hey guys, AUT dev here.

First, we asked a trusted member of BCT to post our ANN because our account is unable to embed images.

Second,
Minereum does exist, but the implementation is pretty piss poor. Here's their code:
https://github.com/minereum/Minereum/blob/master/minereum.sol

Code:

pragma solidity ^0.4.10; 

contract minereum { 

string public name; 
string public symbol; 
uint8 public decimals; 
uint256 public initialSupplyPerAddress;
uint256 public initialBlockCount;
uint256 public rewardPerBlockPerAddress;
uint256 public totalGenesisAddresses;
uint256 private availableAmount;
uint256 private availableBalance;
uint256 private minedBlocks;
uint256 private totalMaxAvailableAmount;
uint256 private balanceOfAddress;



mapping (address => uint256) public balanceOf; 
mapping (address => bool) public genesisAddress; 

event Transfer(address indexed from, address indexed to, uint256 value); 

function minereum() { 

name = "minereum"; 
symbol = "MNE"; 
decimals = 8; 
initialSupplyPerAddress = 3200000000000;
initialBlockCount = 3516521;
rewardPerBlockPerAddress = 32000;
totalGenesisAddresses = 4269;

balanceOf[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = initialSupplyPerAddress;
genesisAddress[0x000018e8a5f1e402763f4d3c2a02288f7f7a7256] = true;
balanceOf[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = initialSupplyPerAddress;
genesisAddress[0x00076f0Cdf32c586a064f4e08c7613521d922e5f] = true;
balanceOf[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = initialSupplyPerAddress;
genesisAddress[0x000779F69bf39d4DF8f007275CF3f90a9A07Adc1] = true;
balanceOf[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = initialSupplyPerAddress;
genesisAddress[0x000adC2EE215Ba7E4f599C4Ff35C35237eD382EA] = true;
balanceOf[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = initialSupplyPerAddress;
genesisAddress[0x000c236D5a264238e8c38FcBd763D6DB049BA126] = true;
...
function currentEthBlock() constant returns (uint256 blockNumber)
{
	return block.number;
}

function currentBlock() constant returns (uint256 blockNumber)
{
	return block.number - initialBlockCount;
}

function availableBalanceOf(address _address) constant returns (uint256 Balance)
{
	if (genesisAddress[_address])
	{
		minedBlocks = block.number - initialBlockCount;
		
		if (minedBlocks >= 100000000) return balanceOf[_address];
		
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
		
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[_address] - totalMaxAvailableAmount;
		
		return availableBalance;
	}
	else
		return balanceOf[_address];
}

function totalSupply() constant returns (uint256 totalSupply)
{	
	minedBlocks = block.number - initialBlockCount;
	availableAmount = rewardPerBlockPerAddress*minedBlocks;
	return availableAmount*totalGenesisAddresses;
}

function maxTotalSupply() constant returns (uint256 maxSupply)
{	
	return initialSupplyPerAddress*totalGenesisAddresses;
}

function transfer(address _to, uint256 _value) { 

if (genesisAddress[_to]) throw;

if (balanceOf[msg.sender] < _value) throw; 

if (balanceOf[_to] + _value < balanceOf[_to]) throw; 

if (genesisAddress[msg.sender])
{
	minedBlocks = block.number - initialBlockCount;
	if (minedBlocks < 100000000)
	{
		availableAmount = rewardPerBlockPerAddress*minedBlocks;
			
		totalMaxAvailableAmount = initialSupplyPerAddress - availableAmount;
		
		availableBalance = balanceOf[msg.sender] - totalMaxAvailableAmount;
			
		if (_value > availableBalance) throw;
	}
}

balanceOf[msg.sender] -= _value; 
balanceOf[_to] += _value; 
Transfer(msg.sender, _to, _value); 
} 
}

Here's ours:

Code:

pragma solidity ^0.4.11;

contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }
  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }
  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }
  function assert(bool assertion) internal {
    if (!assertion) throw;
  }
}
 
contract Autoria is SafeMath {
    // ERC20 variables
    string public constant symbol = "AUT";
    string public constant name = "Autorium";
    uint8 public constant decimals = 18;
    uint256 public _totalSupply = 100000000000000000000000000;

    // Autoria specific variables
    uint256 creationTime = now;
    uint256 gensisBlock = block.number;
    uint256 blocksUntilExhaustion = 2102666;
    
    uint256 public earlySalePrice = 1000000000000000000;
    uint256 public regularSalePrice = 1300000000000000000;
    uint256 public exchangeRate = 17500;
    uint256 public freeTokenSupply = _totalSupply;
    uint256 public retainedSupplyPercentage = 30;
    
    // Owner of this contract
    address issuer;
    
    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
 
    // Balances and aquifers for each account
    mapping(address => uint256) public balances;
    mapping(address => uint256) public aquifers;
    mapping(address => uint256) public initialStake;
    
    // Flag for whether or not address is a well
    mapping (address => bool) public isWell;
 
    // Owner of account approves the transfer of an amount to another account
    mapping(address => mapping (address => uint256)) allowed;
 
    // Functions with this modifier can only be executed by the owner
    // modifiers for permissions on functions
    modifier onlyIssuer() { if (msg.sender == issuer) _; }
    modifier onlyInvestor() { if (msg.sender != issuer) _; }
 
    function aquiferOf(address _owner) public constant returns (uint256 tokens) { return aquifers[_owner]; }
    function getIssuerAddress() public constant returns(address issuerAddress) { return issuer; }
    function getFreeTokenSupply() public constant returns(uint256 tokens) { return freeTokenSupply; }
    function getRetainedSupplyPercentage() public constant returns(uint256 percentage) { return retainedSupplyPercentage; }
    function getCreationTime() public constant returns(uint256 time) { return creationTime; }
    function getGensisBlock() public constant returns(uint256 block) { return gensisBlock; }
    function getBlocksUntilExhaustion() public constant returns(uint256 blocks) { return blocksUntilExhaustion; }
    function getCurrentBlock() public returns(uint256 blocks) { return block.number; }
    
    // Constructor
    function Autoria() {
        // Establish the Issuer
        issuer = msg.sender;
        balances[msg.sender] += 30000000000000000000000000;
        aquifers[msg.sender] = 0;
        freeTokenSupply -= 30000000000000000000000000;
        // Send retainer coins to Issuer
    }

    // ICO Methods
    function paymentProcessor() onlyInvestor payable returns(uint256 tokens){
        
        // see if ICO is still running
        if (freeTokenSupply <= 0) { return 0; }
        if (isWell[msg.sender]) { return 0; }
        // determine exchange rate of AUT (increases if over 1 week after inception)
        uint price = earlySale() ? earlySalePrice : regularSalePrice;

        // set up some basic mapping stuff that we know will exist
        isWell[msg.sender] = true;

        uint requestedTokens = (msg.value / price) * exchangeRate;
        if (requestedTokens > freeTokenSupply) {
            return 0;
        }
        else {
            // send tokents to user
            aquifers[msg.sender] += requestedTokens;
            initialStake[msg.sender] += requestedTokens;
            // send eth to issuer
            issuer.transfer(msg.value);
            // update free token supply
            freeTokenSupply -= requestedTokens;
            return(requestedTokens);
        }
    }

    function earlySale() constant returns (bool ifSo) {
        if ((now - creationTime) > 1 weeks) return false;
        return true;
    }

    // ERC20 Methods 
    function totalSupply() constant returns (uint256 totalSupply) {
        totalSupply = _totalSupply;
        return totalSupply;
    }
    
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balances[_owner];
    }

    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (balances[msg.sender] >= _amount 
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(msg.sender, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function transferFrom(
        address _from,
        address _to,
        uint256 _amount
    ) public returns (bool success) {
        if (balances[_from] >= _amount
            && allowed[_from][msg.sender] >= _amount
            && _amount > 0
            && balances[_to] + _amount > balances[_to]) {
            balances[_from] -= _amount;
            allowed[_from][msg.sender] -= _amount;
            balances[_to] += _amount;
            Transfer(_from, _to, _amount);
            return true;
        } else {
            return false;
        }
    }

    function approve(address _spender, uint256 _amount) public returns (bool success) {
        allowed[msg.sender][_spender] = _amount;
        Approval(msg.sender, _spender, _amount);
        return true;
    }

    function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }
    
    // Autoria specific methods
    
    function availableDraw(address _owner) constant returns(uint256) {
        uint256 x = (initialStake[_owner] / blocksUntilExhaustion) * (block.number - gensisBlock);
        return aquifers[_owner] - (initialStake[_owner] - x);
    }
    
    function drawWell(address _owner) returns(bool) {
        if (isWell[_owner]) {
            //initial aquifer amount - initial aquifer amount 
            uint256 draw = availableDraw(_owner);
            if (draw > 0 && aquifers[_owner] > 0) {
                balances[_owner] += draw;
                aquifers[_owner] -= draw;
            }
            return true;
        }
        return false;
    }
    
}

The original Minereum contract is literally just some dude copying and pasting the addresses people bought into a solidity contract and giving them tokens they can't access for a while.

With Autoria, it's closer to proof of stake. So the more coins you invest in initially, the more you can pull from your 'aquifer.' Also, the ICO is on the blockchain, where Minereum was at the discretion of the creator copying and pasting addresses into the contract. Details are in the whitepaper.

I'll do a video comparing the two in a bit.

the way you talk about other people work was WOW! I'm sure you just some rude scammer and I'm pretty sure you work alone in this shit scam.

[BTC-BTC-BTC]

Is there going to have escrow and teammates?

[lickstaph]

Why only 1% of proceeds go towards the charity? That's only $15000 lmao. Lose the ridiculous premine and maybe I'll look at this.

[tippytoes]

Reading the thread will make you think that there's something unusual here. I don't know if the accusations are true or not, but you cannot tell yet this early. I will watch this thread as the dev for this is bit egotistic over the minereum project.

[atchoum6760]

Other day other scam.

[autoria]

My friend, please don't say lies, people didn't buy the Genesis addresses, they were freely given in an airdrop, so it was a very fair distribution

Hi Voltaje, unfortunately, since the Minereum developer configured the Genesis addresses in an non-transparent manner there's really no way to verify whether or not those addresses were sold or how centralized ownership of MNE is. The developer said he collected IP addresses, but he could have inserted or disqualified any number of addresses without anyone knowing.

Please watch the video where our developer walks through both of the smart contracts if you are interested in learning about why our token is completely different.

[fengzhiyan]

idea copy from MNE
contemptible!!

[TotalPanda]

Autoria is proud to introduce Autorium (AUT), the world's first automatically mined cryptocurrency.

The world's first automatically mined cryptocurrency is Minireum lol



https://bitcointalk.org/index.php?topic=1867535.0

[devlin]

Please remove "First Currency with Automated Mining" it's not true.