Own A Piece Of Binary.com

Best Binary Options Brokers 2020:
  • Binarium

    Top Binary Options Broker 2020!
    Best Choice For Beginners!
    Big Sign-Up Bonus!
    Free Trading Education!
    Free Demo Account!

  • Binomo

    Only For Experienced Traders!

Own A Piece Of Binary.com

Want To Make Money With Binary Options? Own A Broker

If you haven’t noticed there is a new trend in the financial world and binary options is not amused. I’m talking about cryptocurrencies, block chains and ICO’s. While speculators, traders and investors make and lose fortunes in the blink of an eye businesses of all variety are looking for ways to leverage the technology. We’ve already seen the emergence of crypto-based trading platforms and a general shift toward cryptocurrency trading among the brokers. Now we are about to witness the first ever ICO of a broker.

No, this is not like the OTN or Spectre networks. Both of those are block chain based trading technologies coming from know and well established binary options providers. OTN is a stand alone technology that IQOptions has invested in. Their timeline includes establishing IQOption as a crytpocurrency wallet, exchange and trading venue. Spectre is very similar, the difference is it is a white label solution for businesses to build block chain trading businesses upon.

An ERC20 securities token

Jean-Yves Sireau

Read more posts by this author.

Jean-Yves Sireau

Binary.com will be performing an ICO from 15 November to 25 December 2020, offering up to 10 million tokens which offer two exclusive rights: (1) the right to receive dividend-linked payments, and (2) the right to convert tokens into ordinary shares of the company. In practice, the tokens will be economically equivalent to ordinary shares of the company.

Binary.com’s ICO is in effect an “IPO on the Blockchain”. The reasons why we decided to go down this route instead of a traditional IPO are explained in the blog post Why we are doing an ICO (and not an IPO).

Whereas 2020 has been the year of the “utility token”, we believe that 2020 will usher in the era of the “securities token”, where an increasing number of companies worldwide decide to list on the blockchain directly, bypassing the often archaic and expensive traditional stock exchanges.

ERC20 securities tokens however need to implement quite a number of features that are not required for utility tokens. Indeed, companies listed on the blockchain will need to be able to perform the full gamut of corporate actions that they would have been able to perform if they had opted to list on a traditional stock exchange.

For this reason, Binary.com decided to adopt the Mini Me ERC20 token. This token provides unique features that are appropriate for a securities token. One of its most important features is the ability to clone itself at a given block count, effectively creating a “mini me” version of itself. It is this ability to create clones/forks of the token that becomes useful to implement the common types of corporate action, as detailed below.

Note: Binary.com tokens will use the symbol BINARY.

Dividend-linked payments

The Binary.com tokens entitle the holder to receive payments equivalent to the dividends paid on ordinary shares of the Company. To implement the dividend feature, Binary.com will clone the BINARY token at a given block height. The cloned token, which all BINARY tokenholders will inherit, will represent dividend rights.

By way of illustration, Binary.com may declare a dividend of $0.02 per share, payable at Ethereum block height 4518852. The symbol for this dividend right would be BINARY_DIVIDEND_USD2c_4518852. This token is essentially an IOU for $0.02 payable by Binary Group Ltd. (Note: this is by way of illustration only; actual dividend amounts and block heights will be declared by the company in due course over time). Concurrently, the same amount of dividend will be paid to shareholders of the company.

Tokenholders would have two possibilities to cash out this dividend right: (1) they could trade the token on a cryptocurrency exchange (if it gets listed) – in which case it would be natural to expect that the token’s value would be essentially fixed at $0.02, or (2) they could redeem the token for $0.02 (or equivalent in other cryptocurrency) from Binary Group Ltd.

Best Binary Options Brokers 2020:
  • Binarium

    Top Binary Options Broker 2020!
    Best Choice For Beginners!
    Big Sign-Up Bonus!
    Free Trading Education!
    Free Demo Account!

  • Binomo

    Only For Experienced Traders!

In regards to (1), the dividend rights become in effect freely tradable fiat currency-backed IOUs, similar to Tether tokens.

In regards to (2), i.e. redeeming the dividend right token from Binary.com, the tokenholder would need to log into his Binary.com account, ensure that his/her account is authenticated (to fufil KYC – Know your client requirements), and then deposit the dividend right using the facilities provided. Once the dividend right is deposited, $0.02 per dividend right token will be deposited to the user’s Binary.com USD account.


The BINARY token is governed by a Token Instrument, which may be amended by majority vote of the tokenholders. Such voting shall take place by cloning the BINARY token to issue voting rights.

Such voting rights may be exercised by tokenholders by sending the token either to a pre-defined “Yes” Ethereum address or a pre-defined “No” address.

Mergers and Acquisitions

One reason why companies list on a stock exchange is so that they can use their listed shares as ‘currency’ to acquire other companies (or sometimes to merge into them). This is done by issuing new shares as payment for the acquisition of the shares of the other company.

On the blockchain using the Minime token, such acquisitions would be performed by issuing new tokens using the generateTokens() function. Typically utility tokens don’t have such a function, because they are part of a closed ecosystem where issuing new tokens would unfairly dilute existing tokenholders. The issuance of new securities tokens in an acquisition does dilute existing tokenholders, however the benefit is that the company now has larger assets due to the acquisition. i.e. smaller percentage of a larger pie.

Change of symbol

Although it is unlikely that Binary.com would need to change its token symbol, a symbol change could be performed by cloning the BINARY token, with the clone having a new symbol, and then destroying the original BINARY token.

Rights issues

As described in Wikipedia, a rights issue is a dividend of subscription rights to buy additional securities in a company made to the company’s existing security holders. It is a non-dilutive pro rata way to raise capital.

Rights issues would be performed on the blockchain by cloning the BINARY token at a specified block height, hence creating the Right. Such Right may be exercised by sending it to a specified address/smart contract with a sufficient amount of Ether attached to exercise the Right under its terms. The MiniMe token doesn’t currently support this, hence a new token would need to be created that would fork the BINARY token.


The issuance of warrants or options can also be performed by cloning the main token and providing a smart contract for the redemption of the warrants or options. Since the MiniMe token doesn’t directly support transferring Ether alongside the Token, as per the Rights Issue case a new token would need creating to implement warrants/options issuance.


Jean-Yves Sireau

Jean-Yves Sireau is founder of Binary.com

More posts by Jean-Yves Sireau.

Jean-Yves Sireau

Bitcoin works by having miners validate transactions that are technically short scripts written in a very simple scripting language. If the script runs and doesn’t return an error, it’s a valid transaction and gets included in the blockchain. That’s how you’re able to have m-of-n transactions, timelocked transactions, microtransaction channels, etc.

Ethereum’s core difference is that its scripting language is Turing complete, with each operation in the scripting language having a specific cost that informs the fee required for each transaction. So now you can write Smart Contracts which are much more powerful contracts than you ever could with Bitcoin.


The Ethereum releases are:

  • Prerelease Step 0: Olympic testnet – launched May 2020
  • Release Step One: Frontier – launched 30 July 2020
  • Release Step Two: Homestead – launches 14 March 2020 (Pi Day)
  • Release Step Three: Metropolis – TBA
  • Release Step Four: Serenity – TBA

Homestead was introduced automatically at block 1,150,000.


Ethereum also has it’s own cryptocurrency token called Ether, denominated ETH. Ether is also used to pay for transaction fees and computational services on the Ethereum network.

Every 12 seconds, on average, a new block is added to the blockchain with the latest transactions processed by the network and the computer that generated this block will be awarded 5 ether.

All ether balances and values are denominated in units of wei: 1 ether is 1e18 wei.

Gas is the internal pricing for running a transaction or contract in Ethereum. Gas can only be paid for in Ether. You can view the current gas price at Etherscan.

Ethereum Virtual Machine

The Ethereum Virtual Machine (EVM) is the runtime environment for smart contracts. It is sandboxed and also completely isolated from the network, filesystem or other processes of the host computer system. Every Ethereum node in the network runs an EVM implementation and executes the same instructions. Ethereum Virtual Machines have been implemented in C++, Go, Haskell, Java, and other languages.

Smart Contracts

Smart contracts are compiled down to EVM bytecode and deployed to the Ethereum blockchain for execution. They can be written in Solidity (a language library with similarities to C and JavaScript), Serpent (similar to Python), LLL (a low-level Lisp-like language), and Mutan (Go-based, but deprecated).

Currently, the Ethereum protocol could process only 25 transactions per second. This is because every node is calculating all the smart contracts in real time.


Like in Bitcoin, users must pay small transaction fees to the network. The sender of a transaction must pay (with Ether) for each step of the “program” they activated, including computation and memory storage.

These transaction fees are collected by the miners, which are nodes in the Ethereum network that receive, propagate, verify, and execute transactions. The miners then group the transactions – which include many updates to the “state” of accounts in the Ethereum blockchain – into what are called “blocks”. Just as in the Bitcoin network, miners are tasked with solving a complex mathematical problem in order to successfully “mine” a block (“Proof of Work”). Ethereum chose a memory-hard computational problem (Ethash), to discourage the use of ASICs.


Whereas the Bitcoin blockchain was purely a list of transactions, Ethereum’s basic unit is the account. The Ethereum blockchain tracks the state of every account, and all state transitions on the Ethereum blockchain are transfers of value and information between accounts. There are two types of accounts:

  • Externally Owned Accounts (EOAs). An EOA:
  • can send transactions (ether transfer or trigger contract code);
  • is controlled by private keys;
  • has no associated code.
  • Contract Accounts, which are controlled by their contract code and can only be “activated” by an EOA. A Contract Account:
  • has associated code,
  • code execution is triggered by transactions or messages (calls)
    received from other contracts.
  • when executed: can perform operations of arbitrary complexity (Turing completeness) and can manipulate its own persistent storage, i.e., can have its own permanent state, and can call other contracts.

Contracts generally serve four purposes:

  • Maintain a data store representing something which is useful to other contracts or to the outside world.
  • Serve as a sort of externally-owned account with a more complicated access policy; this is called a “forwarding contract” and typically involves simply resending incoming messages to some desired destination only if certain conditions are met.
  • Manage an ongoing contract or relationship between multiple users.
  • Provide functions to other contracts, essentially serving as a software library.

For most users, the basic difference between EOAs and Contract Accounts is that human users control EOAs – because they can control the private keys which give control over an EOA. Contract accounts, on the other hand, are governed by their internal code.

All action on the Ethereum block chain is set in motion by transactions fired from externally owned accounts. By default, the Ethereum execution environment is lifeless; nothing happens and the state of every account remains the same. However, any user can trigger an action by sending a transaction from an externally owned account, setting Ethereum’s wheels in motion. If the destination of the transaction is another EOA, then the transaction may transfer some ether but otherwise does nothing. However, if the destination is a contract, then the contract in turn activates, and automatically runs its code.

Each account has a persistent memory area which is called storage. Storage is a key-value store that maps 256-bit words to 256-bit words. A contract can neither read nor write to any storage apart from its own.

The second memory area is called memory, of which a contract obtains a freshly cleared instance for each message call. Memory is linear and can be addressed at byte level, but reads are limited to a width of 256 bits, while writes can be either 8 bits or 256 bits wide.

There is no visual way to check if an address is a contract or an EOA. One of the goals of Ethereum is for humans and smart contracts to both be treated equally. You can however use a blockchain scanner to check if there is any code at the address.

Unlike Bitcoin, there is no need for Hierarchical Deterministic (HD) wallets in Ethereum. Bitcoin operates under a UTXO (unspent transaction output) system, which necessitates new addresses for each transaction. Ethereum, in contrast, operates on an account based system. While it would be possible to deterministically generate a tree of accounts from a single seed in Ethereum, there’s really no need to, because a single account can handle all of your transactions. The only reason to use a HD wallet would be for extra privacy.

Smart Contracts

The term smart contracts refers to code in a Contract Account.

It isn’t possible to decompile a smart contract back to Solidity source code, but you can decompile the bytecode into opcodes – for example use etherchain.org

Private keys, Public keys, and Addresses

For an EOA, there are three main steps to get from private key to address:

  1. Create a random private key (64 (hex) characters / 256 bits / 32 bytes)
  2. Derive the public key from this private key (128 (hex) characters / 512 bits / 64 bytes)
  3. Derive the address from this public key. (40 (hex) characters / 160 bits / 20 bytes)

Private keys are 64 hexadecimal characters. Every single string of 64 hex are, hypothetically, an Ethereum private key that will access an account.

An Ethereum address represents an account. For an EOA, the address is derived as the last 20 bytes of the public key controlling the account, e.g., `cd2a3d9f938e13cd947ec05abc7fe734df8dd826. This is a hexadecimal format (base 16 notation), which is often indicated explicitly by appending 0x to the address. Ethereum addresses are hence 40 hexadecimal characters and start with a 0x.

Even though a lot of people call the address the public key, it’s actually not the case in Ethereum. There is a separate public key that acts as a middleman that you won’t ever see.

Note: Never enter an Ethereum address manually! Ethereum addresses don’t have checksums.

Whereas the address of an EOA is determined from the public key, the address of a contract account is determined at the time the contract account is created (it is derived from the creator address and the number of transactions sent from that address, the so-called “nonce”).


Accounts are the most basic way to store Ether. They are simple public/private keypairs, which you use to sign transactions. You don’t need to do anything to “register” an account with the network, just generate one and send some ether to it.

Wallets are smart-contracts that allow for advanced features such as transaction logging, multisig, withdrawal limits, and more. In order to create a wallet, you need to deploy the contract to the blockchain, which requires Ether. You need to make sure you keep track not only of the keys required to access the wallet, but also the wallet address. Unlike with accounts, wallet addresses are not very easily derivable from the private key (although it’s not the end of the world if you lose the wallet address, you can use a block explorer to find what contracts you’ve created recently). Technically you can recover the address from just the account that created it and the nonce of the transaction, but that’s a hassle.

Creating Accounts does not cost any gas; but creating Wallets does. In fact, Wallets incur a cost whenever you use them.


The term transaction is used in Ethereum to refer to the signed data package that stores a message to be sent from an externally owned account to another account on the blockchain.

  • the recipient of the message,
  • signature identifying the sender and proving their intention to send the message via the blockchain to the recipient,
  • VALUE field – The amount of wei to transfer from the sender to the recipient,
    an optional data field, which can contain the message sent to a contract,
  • a STARTGAS value, representing the maximum number of computational steps the transaction execution is allowed to take,
  • a GASPRICE value, representing the fee the sender is willing to pay for gas. One unit of gas corresponds to the execution of one atomic instruction, i.e., a computational step.

Contracts have the ability to send messages to other contracts. Messages can be conceived of as function calls.

A message contains:

  • the sender of the message (implicit).
  • the recipient of the message
  • VALUE field – The amount of wei to transfer alongside the message to the contract address,
  • an optional data field, that is the actual input data to the contract
  • a STARTGAS value, which limits the maximum amount of gas the code execution triggered by the message can incur.

Essentially, a message is like a transaction, except it is produced by a contract and not an external actor.


A node is a piece of software that connects to other nodes, thus participating in the formation of the Ethereum network. A node stores the blockchain, and a node may mine (but doesn’t have to). All interaction with the blockchain (interaction with contracts, etc) needs to go via a node.

If you don’t wish to run your own node, you can use a public one such as Infura.io.

View a map of Ethereum nodes at Ethernodes.org


An Ethereum client refers to any node able to parse and verify the blockchain, its smart contracts and everything related. It also allows you/provides interfaces to create transactions and mine blocks which is the key for any blockchain interaction.

  • Official reference implementations (CLI)

eth – C++ client of the webthree project. It was formerly known as cpp-ethereum: https://github.com/ethereum/webthree-umbrella

  • Official reference implementations (GUI)

mist which works on top of geth or eth and aims to be a DApp browser and currently implements the ethereum-wallet-dapp. https://github.com/ethereum/mist

alethzero is internally called the hardcore client but it’s being deprecated. https://github.com/ethereum/alethzero
Third party implementations (CLI)

  • Non-official clients implementing the yellow paper specification are:

ethereumH – Haskell client from consensys, but it’s not developed anymore: https://github.com/jamshidh/ethereum-client-haskell

  • Third party implementations (GUI)

Ethereum enables the decentralised web, referred to as ‘web 3’. The web3 stack is:

A Dapp (‘decentralized app’) consists of two parts: a frontend, written in HTML, and a backend (think of it as the ‘database’ for the frontend).

Good news for developers: if you like bootstrap, or any other framework, you can continue using them, as the frontend of dapps have full network access. In fact, for all intent and purposes, developing a frontend for a Dapp written HTML is the exact same as developing a website.

Because Ethereum relies on cryptographic principles to function, every Dapp knows the pseudonymous identity of each user. Hence users won’t need to ‘create accounts’ or ‘log on’ to access your dapps.

The frontend code ‘listens’ to changes on the blockchain and visually update the client as it is notified of updates. It can also makes calls to the underlying backend code in the form of calls to smart contracts functions, usually with the help of web3.js.

An ideal dapp should be unstoppable. The backend question is taken care off by using smart contracts on the Ethereum blockchain. For the frontend, an ideal dapp would not be hosted anywhere centralized, but instead held a self-contained, compressed package within a decentralized storage platform such as SWARM.

That package would decompress into a series of folders and files, which would be recognized by an Ethereum browser as a valid dapp structure. At the moment, that structure consists of HTML + JS files, often in the form of a Meteor static assets.

This package would be digitally signed and referenced from within the blockchain itself in order for the author to invalidate it and ‘force’ a software update whenever needed.

dApp browsers

Dapp browsers include the following:

  • Mist – official GUI dapp browser developed by the foundation.
  • Status – Mobile Ethereum browser.
  • MetaMask – An in-browser GUI.
Ethereum Name Service (ENS)

The primary goal of ENS is to resolve human-readable names, like ‘myname.eth’, into machine-readable identifiers, including Ethereum addresses and other identifiers.

Top-level domains, like ‘.eth’ and ‘.test’ are owned by smart contracts called registrars, which specify rules governing the allocation of their subdomains.

ENS is deployed on mainnet at 0x314159265dd8dbb310642f98f50c066173c1259b, where users may register names under the eth TLD, which uses an auction based registrar.

To register a name go to ens.domains

ERC20 tokens

Ethereum tokens are not built into its blockchain. To remedy this problem, the EIP20 protocol has been accepted by Ethereum community and became the first standard protocol for token creation and development (ERC20).

The following is an interface contract declaring the required functions and events required to meet the ERC20 standard:

The meanings of these functions are:

  • totalSupply() – Total number of tokens in circulation
  • balanceOf(A) – Number of tokens belonging to A
  • transfer(A,x) – Send x tokens to A
  • transferFrom(A,x) – Withdraw x tokens from A
  • approve(A,x) – Approve A to withdraw tokens from me
  • allowance(A,B) – How much B can withdraw from A

Most of the major tokens on the Ethereum blockchain are ERC20-compliant. View popular tokens or use the Etherscan token search or ethplorer.io.

A minimal open-source ERC20 dashboard/wallet (that uses etherscan as node provider) can be found at https://github.com/noxonsu/noxonsu.github.io

You may issue and interact with tokens using https://tokenfactory.surge.sh

Note: the ERC223 standard is a newer standard that can also be considered.


The best way to start with Solidity is to use the Remix browser-based IDE, or Ethereum Studio.

The Solidity docs are located at readthedocs.io.

Here are some basic concepts:

  • The version pragma pragma solidity ^0.4.0; indicates the source file will not compile with a compiler earlier than version 0.4.0.

import “filename”; imports all global symbols from “filename”.

  • uint storedData; defines a state variable of type uint which will be permanently stored in contract storage.

modifier onlySeller() <. >Modifiers can be used to easily change the behaviour of functions, for example to automatically check a condition prior to executing the function.

function abort() onlySeller <. >Functions are the executable units of code within a contract.

struct Voter < uint weight; bool voted; >Structs are custom defined types that can group several variables.

enum State < Created, Locked, Inactive >Enums can be used to create custom types with a finite set of values.

  • bool , int / uint , address (Holds a 20 byte value, which is the size of an Ethereum address).
  • bytes1 , bytes2 .. are fixed-size byte arrays.
  • mapping(address => uint) public balances; Mappings can be seen as hashtables which are virtually initialized such that every possible key exists
Do it yourself training!

Here are some exercises to experience Ethereum for yourself:

  • Use Shapeshift to convert some BTC into ETH and send it to the ETH address you just created. Note that shapeshift asks for a BTC refund address; this is used only if there is a failure of some sort.
  • Create a new address, and send your ETH from your first to your second address using https://www.myetherwallet.com/#send-transaction
  • Create ERC20 token

to be continued.

Subscribe to Binary.com company blog

Get the latest posts delivered right to your inbox

More in Software Development

Front-End Projects at Binary.com

26 Mar 2020 – 2 min read

Scrum and XP from the Trenches [Book Summary]

5 Sep 2020 – 11 min read

Why Bitcoin will keep rising for a very long time

Bitcoin may have risen 1,102,682-fold (!) since Laszlo Hanyecz bought two pizzas for BTC 10,000 in May 2020, but it has the potential to go a lot further

Best Binary Options Brokers 2020:
  • Binarium

    Top Binary Options Broker 2020!
    Best Choice For Beginners!
    Big Sign-Up Bonus!
    Free Trading Education!
    Free Demo Account!

  • Binomo

    Only For Experienced Traders!

Like this post? Please share to your friends:
Binary Options Trading Secrets
Leave a Reply

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: