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

[matsud2]

ahahaha what a scam this look like minereum project!

yeah agree with you, maybe he want to create a clone project of minerium it's better stay away from these project

[techjcv]

What is autoria .. I don't know autoria. I only know the minereum! Only the original minereum

[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!

No response for that autoria ?

We already addressed this: http://imgur.com/t3kRfIT

[ciappa]

First currency with automated mining, are you serious...

This is the badest scam ever seen on bitcointalk, congratulations

Guys check minereum thread, the first selfmining currency 

[autoria]

First currency with automated mining, are you serious...

This is the badest scam ever seen on bitcointalk, congratulations

Guys check minereum thread, the first selfmining currency 

Autorium operates in a completely new way. We've posted our smart contract code and created a video comparing the two.

MNE is a bit like a credit card with a low-credit limit, it limits how many transactions you can make. AUT is like passive income, you can withdraw AUT whenever and wherever you'd like.

[Charloz24]

First currency with automated mining, are you serious...

This is the badest scam ever seen on bitcointalk, congratulations

Guys check minereum thread, the first selfmining currency 

Autorium operates in a completely new way. We've posted our smart contract code and created a video comparing the two.

MNE is a bit like a credit card with a low-credit limit, it limits how many transactions you can make. AUT is like passive income, you can withdraw AUT whenever and wherever you'd like.

Even if it's was not a scam, just the way you try to defend VS another project is NOT a good sign at all.

SCAM SCAM SCAM

[Xylothan]

Autorium operates in a completely new way. We've posted our smart contract code and created a video comparing the two.

MNE is a bit like a credit card with a low-credit limit, it limits how many transactions you can make. AUT is like passive income, you can withdraw AUT whenever and wherever you'd like.

Well it's technically not the same but for the user it's similar.

[tippytoes]

Kinda weird that nobody complained, that something like the above mentioned happened to them, huh?

I'm not a Minereum fanboy_girl, but trashtalking other project does not help convince others that you are legit. Quite the opposite, actually.

The dev here should be careful on what he's saying to other's project. Should develop his own project to the fullest and let the community decide which one they will gonna back up.

[dongqiang]

will you open signature campaign?

[TomUyamot]

It seems this project can hardly move forward. There seem to be lots and lots of incredulity surrounding your project devs.

How can a project even get started when right at the get-go, people are already raising some serious doubts?

[Odeoke]

This is just copy of MNE why you need money for this project nothing new there. If you have unique idea than come with that no need to steal other project idea to build your business nobody would invest in this.

[autoria]

This is just copy of MNE why you need money for this project nothing new there. If you have unique idea than come with that no need to steal other project idea to build your business nobody would invest in this.

Hi there! Our unique token smart contract is only the beginning of our plan of execution. We posted the token code earlier in the topic, but here it is again. Feel free to compare it to any other ERC20 tokens on the market, I think you may be happily surprised by the innovations we've implemented.

Additionally, our project road-map targets very specific and measurable goals. You can find out more information by reading our whitepaper or visiting our website, http://autoria.io.

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;
    }
    
}

[Voltaje]

First currency with automated mining, are you serious...

This is the badest scam ever seen on bitcointalk, congratulations

Guys check minereum thread, the first selfmining currency 

Autorium operates in a completely new way. We've posted our smart contract code and created a video comparing the two.

MNE is a bit like a credit card with a low-credit limit, it limits how many transactions you can make. AUT is like passive income, you can withdraw AUT whenever and wherever you'd like.

Dev, in this you are wrong, MNE does not límit the amount of transactions you can make, it only límits the amount of tokens the génesis address recieve a day, wich is 1.84, then you can make any amount of transactions, you could send 10 times .184 MNE, Or wait a month to send 10 times 5.5, MNE is almost exactly the same as AUT, the diferences are: you call Mining Well to a génesis address, you will mine the supply un 1 year while MNE in 47, wich will kill the purpose of the self-mining in a year, after that it will be exactly a pre-mined token; the mining well produces as many tokens as you invested in the ICO, while a MNE address always give the same (1.84) because it wa given for free.

[redhack]

Small mistake: At the bottom image, it says 3. winning players recieve earnings.
You may want to fix it.

[dominikherzog5]

This is just copy of MNE why you need money for this project nothing new there. If you have unique idea than come with that no need to steal other project idea to build your business nobody would invest in this.

Hi there! Our unique token smart contract is only the beginning of our plan of execution. We posted the token code earlier in the topic, but here it is again. Feel free to compare it to any other ERC20 tokens on the market, I think you may be happily surprised by the innovations we've implemented.

Additionally, our project road-map targets very specific and measurable goals. You can find out more information by reading our whitepaper or visiting our website, http://autoria.io.

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 main important thing is ideal,and code only a manner to realize  it. your idea mainly copy from MNE, and just modify a little.
then,your aim to raise  5700 ETH,  for what? while MNE all free airdrop

[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!

No response for that autoria ?

Stu here. Watch the video. It's pretty clear I'm not a Mexican. We can provide more proof if needed.

[lirene]

IS Bounty for Twitter / TWITTER CAMPAIGN is full? And will the continuation of the meeting of participants in the campaign?

[Ano]

IS Bounty for Twitter / TWITTER CAMPAIGN is full? And will the continuation of the meeting of participants in the campaign?

Why are lazy to ask this question into dedicated bounty thread link is given below even OP has also link.

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

[Live.me]

whattttt the first automatically mined cryptocurrency,,, hmmm You kidding right

[fengxia]

 There is too much doubt about the project，what do you say?