Trustnodes Launches IEO Token

0

Without completing any paperwork, without requiring the assistance or the permission of anyone, without knowing how to code, in a legally compliant manner and for the total cost of $0.50, an Initial Exchange Offering (IEO) – from token creation to exchange listing – has been completed in about ten minutes.

The process begins by copy pasting the token template code from the “official” source.

We removed any backdoors and other “advanced” features like freezing transactions or reversing them, and copy the code that creates a plain token which gives us 1,000,000 in supply and then keeps track of balances and how ownership changes. This is the code in its entirety:

pragma solidity >=0.4.22 <0.6.0;

interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes calldata _extraData) external; }

contract Trustnodes {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;

// This creates an array with all balances
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;

// This generates a public event on the blockchain that will notify clients
event Transfer(address indexed from, address indexed to, uint256 value);

// This generates a public event on the blockchain that will notify clients
event Approval(address indexed _owner, address indexed _spender, uint256 _value);

// This notifies clients about the amount burnt
event Burn(address indexed from, uint256 value);

/**
* Constrctor function
*
* Initializes contract with initial supply tokens to the creator of the contract
*/
constructor(
uint256 initialSupply,
string memory tokenName,
string memory tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
}

/**
* Internal transfer, only can be called by this contract
*/
function _transfer(address _from, address _to, uint _value) internal {
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != address(0x0));
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this for an assertion in the future
uint previousBalances = balanceOf[_from] + balanceOf[_to];
// Subtract from the sender
balanceOf[_from] -= _value;
// Add the same to the recipient
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
// Asserts are used to use static analysis to find bugs in your code. They should never fail
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}

/**
* Transfer tokens
*
* Send `_value` tokens to `_to` from your account
*
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transfer(address _to, uint256 _value) public returns (bool success) {
_transfer(msg.sender, _to, _value);
return true;
}

/**
* Transfer tokens from other address
*
* Send `_value` tokens to `_to` in behalf of `_from`
*
* @param _from The address of the sender
* @param _to The address of the recipient
* @param _value the amount to send
*/
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]); // Check allowance
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}

/**
* Set allowance for other address
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
*/
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}

/**
* Set allowance for other address and notify
*
* Allows `_spender` to spend no more than `_value` tokens in your behalf, and then ping the contract about it
*
* @param _spender The address authorized to spend
* @param _value the max amount they can spend
* @param _extraData some extra information to send to the approved contract
*/
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
}

/**
* Destroy tokens
*
* Remove `_value` tokens from the system irreversibly
*
* @param _value the amount of money to burn
*/
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
emit Burn(msg.sender, _value);
return true;
}

/**
* Destroy tokens from other account
*
* Remove `_value` tokens from the system irreversibly on behalf of `_from`.
*
* @param _from the address of the sender
* @param _value the amount of money to burn
*/
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value); // Check if the targeted balance is enough
require(_value <= allowance[_from][msg.sender]); // Check allowance
balanceOf[_from] -= _value; // Subtract from the targeted balance
allowance[_from][msg.sender] -= _value; // Subtract from the sender’s allowance
totalSupply -= _value; // Update totalSupply
emit Burn(_from, _value);
return true;
}
}

That’s it. 159 lines of code. It should be bug free, but we do hopefully have Solidity experts that read these pages, so if anything do let us know.

We copy pasted that code into Remix to compile it, which is basically turning it into a language of random numbers and letters that computers understand.

Compiling token smart contract, April 2019.

Before deploying it, we’ve entered the basic parameters of supply, name and symbol after clicking the arrow next to “Deploy.”

You can see this connects to MetaMask through Inject Web3. So we’re ready and click transact at which point we are asked to confirm:

Confirming token smart contract publication, April 2019.

Once we scroll down and confirm, we have to confirm it on MetaMask as well and then run to etherscan to see this:

Token smart contract created, April 2019.

It’s done, it’s live, but let’s see if it actually works. So first let’s add this token to our MetaMask:

Adding a token to MetaMask, April 2019.
Adding a token to MetaMask, April 2019.

Once we pasted the smart contract address, the symbol was automatically filled, so that was a good sign. After clicking next, we’re now very sure we have 1 million Trustnodes tokens:

Trustnodes tokens supply and ownership confirmed on MetaMask, April 2019.

Good. To confirm it all works, we sent 100 TRN to the donation address shown at the footer of these pages:

Sending token, April 2019
Confirmed token sent, April 2019

Yup, it works. Balances changed. The tokens moved. It is doing exactly what it is meant to do, which is quite exciting because this wasn’t possible until very recently.

So to complete the Initial Exchange Offering, we have to list it somewhere. Interestingly, the decentralized exchange (dex), EtheDelta, allows anyone to list any token for trading against eth unlike some dexs which have listing criteria and so on.

You just go to EtherDelta, scroll through the tokens to reach the bottom and then click other. At that point you get a pop-up like this:

Listing token on EtherDelta, April 2019.

Once you click go and the on-chain transaction confirms, the trading market is up. You can now enter your sell orders, buy orders, and basically you’re on an exchange:

Trustnodes token listed, April 2019.

To test it all works, we had the first trade for pennies (two 0.002 eth transactions) after listing 260 eth ($43,000) worth of TRN with some joker later adding those sell orders for ◊10 and 100 eth per TRN.

You’ll notice our balance is 899,900 TRN. That’s because 100 was initially transferred and 100,000 has been deposited to EtherDelta. That’s now been reduced by 4 TRN as they were sold for 0.004 eth.

First Trustnodes TRN trade, April 2019.

That’s that, finished. If we can do it, anyone can. All you need is MetaMask plus some eth to pay for gas and what costs millions in traditional markets can be done for 50 cent.

EtherDelta is obviously not as convenient as a centralized exchange. It is somewhat slow, much does happen on-chain and it can be counterintuitive in that you have to click on the buy or sell orders, instead of entering a limit order above the buy or sell orders.

It works however. It does do its basic function of allowing people to say what they are willing to buy or sell and for how much. All of it is done fairly instantly without any need for registration.

So allowing us to complete the entire process without any intermediaries, without any middlemen, without paying any fee to anyone and even without speaking to anyone.

All of it in a fully legal manner as well, at least as far as we understand it, under an exemption to the Securities Act requirements. The Securities and Exchanges Commission (SEC) says:

“Rule 504 permits certain issuers to offer and sell up to $1 million of securities in any 12-month period. These securities may be sold to any number and type of investor, and the issuer is not subject to specific disclosure requirements. Generally, securities issued under Rule 504 will be restricted securities (as further explained below), unless the offering meets certain additional requirements…

You should not expect to be able to easily and quickly resell your restricted securities. In fact, you should expect to hold the securities indefinitely.

There are two principal things to think about before buying restricted securities. The first is that unless you have made arrangements with the issuer to resell your restricted securities as part of a registered offering, you will need to comply with an exemption from registration to resell.

One rule commonly relied upon to resell requires you to hold the restricted securities for at least a year if the company does not file periodic reports (such as annual and quarterly reports) with the SEC.”

By certain issuers they mean publicly traded companies obviously can’t rely on this exemption. So anyone can raise up to $1 million in any 12 months period with the buyers then unable to sell it on for 12 months.

So the joker above has technically breached the law in offering TRN for sale minutes after buying them, but it’s obviously a joke.

Since nothing is being promised in return for these tokens and since they don’t provide ownership in the company, arguably they don’t meet the definition of a security.

SEC’s chair however happens to be a former elite bankers’ lawyer, so he says effectively they’re securities regardless, something that has not yet been challenged in court.

The $1 million exemption applies in any event, and if SEC says these are securities, then arguably ownership in potential future profits can perhaps be given, but is not being promised.

Such profit sharing by effectively giving dividends in a roundabout way of burning some of the supply would be one use case for these sort of tokens.

Another one in this case could be unfiltered access to Trustnodes if one has say 100 TRN. To fund its operations, Trustnodes has a subscription paywall. Instead of paying $5 a month, the option could be offered to log in with MetaMask which then checks if you have 100 TRN. If you do, then you don’t hit the paywall.

That use case makes it very difficult to draw the line between a utility token, which is not subject to the Securities Act, and a securities offering.

Obviously asking people to pay $5 a month to access our articles is not a security. Why that would be any different if it was done through a token, is not very clear.

In any event, there’s the $1 million exemption. That has no restriction on advertising as far as we understand (not that we’re undertaking any), so generally this should be compliant with US laws.

Europe has more lax requirements, with this probably not even considered a securities offering, but the point was to show just how easy it is and how any smart young man or woman with an entrepreneurial drive can raise capital through a process that takes about 10 minutes.

So the 26 billionaires who now own as much wealth as half of the world in part because the Securities Act limits investments in start-ups to just the rich, might be facing some competition.

Just as may all the intermediaries, including crypto exchanges, which require all sorts of at times huge fees to complete the above process.

With decentralized finance now taking root, it can all instead be done for 50 cent from the comfort of your home for the show must go on. The revolution can not be delayed, let alone stopped.

Copyrights Trustnodes.com 

 

Comment

100000
  Subscribe  
Notify of