A purely peer-to-peer version of an electronic payment method would allow online payments to be directly sent from one party to another without going through a financial institution. A digital signature is a part of the solution; however, the main benefits are lost if a trusted third party is still required to prevent double-spending. The solution suggested for this double-spending problem is using a peer-to-peer network. The network timestamps transactions are conducted by hashing them into a continuous chain of hash-based proof of work, which creates a record that cannot be changed without recreating the proof-of-work. The most prolonged chain not only serves as proof of the sequence of witnessed events but it also works to ensure that it comes from the largest pool of CPU power. As long as the majority of CPU power is controlled by nodes that do not cooperate to attack the network, they will generate the longest chain and be faster than the attackers. The network itself requires only a minimal structure. Messages are transmitted on a best-effort basis, and the nodes can arbitrarily leave and re-enter the network, accepting the longest proof-of-work chain as proof of what happened while they are away.
Very similar to the bitcoin algorithm, more than 16.800.000 coins have already been mined and less than 4.800.000 coins are being mined by the people around the world.
Counos Coin does not enjoy any central authority or middleman. But support on the part of a professional team to make it more useful will be available in the near future.
We define an electronic coin as a chain with digital signatures. Each owner transfers the coin to the next one by signing a hash of the previous transaction and the next owner's public key and appending it to the end of the coin digitally. The recipient of the payment can verify the signatures to confirm the owners’ chain.
The problem, of course, is that the payee cannot verify the duplication of the coin by any owner. One standard solution is to introduce a central, trustful instance, or mint, that checks each transaction for double-spending. After each purchase, the Coin must be returned to the Mint for a new Coin to be issued, and just the Coins directly issued from the Mint can be trusted on to have not been duplicated. The problem with this solution is that the fate of the entire monetary system depends on the company running the mint and that every transaction has to go through it like a bank.
We need a method to assure the payee that the previous owners did not sign previous transactions. For our purposes, the first transaction is the one that counts, so we do not have to worry about later multiple-issue attempts. The only way to confirm the absence of a transaction is to identify all transactions. In the mint-based model, the Mint recognized all the transactions and could decide which ones had arrived first. To do this without a trusted party, transactions must be made public, and we need a system whereby subscribers agree on a single history of the order in which they arrived. The payee requires proof that at the time of each transaction, the majority of the nodes of the network agree that they have received them first.
The solution we have proposed starts with a timestamp server. A timestamp server works by taking the hash of a block of time-stamped records and publishing the hash widely, such as in a newspaper or an Usenet Post. The timestamp proves that the data existed at this point; otherwise, it is clear that there would be no hash of them. Each timestamp contains the previous timestamp in its hash and forms a chain wherein each additional timestamp strengthens the previous timestamps.
To implement a peer-to-peer distributed timestamping server, we need to use a proof-of-work system, similar to the Adam Back hash system instead of newspapers or Usenet Posts. The proof-of-work involves finding a value where, when hashed, such as through SHA-256, the hash begins with a count of zero bits. The average work required is exponential to the number of zero bits needed and can be verified by the execution of a single hash. For our timestamp network, we implement the proof-of-work by raising a nonce in the block until a value is found that gives necessary zero bits to the hash of the block. After the CPU has put in enough work to do the proof-of-work, the block cannot be changed without rerunning the job. The work to replace the block would involve recreating all subsequent blocks until later blocks are chained to it. The proof-of-work also solves the problem of determining the majority in majority voting. If the majority is based on one vote per IP address, it could be infiltrated by anyone who can reserve many IPs. Proof-of-work is one vote per CPU. The majority vote is represented by the longest chain in which the largest proof-of-work effort has been invested. If a majority of CPU power is controlled by honest nodes, the straight chain will grow by its fastest speed, and all competing chains will depend. To change a past block, an attacker would have to recreate the proof-of-work of the block as well as all subsequent blocks, and then catch up with and overtake the honest nodes. Later, we will demonstrate that the more blocks they follow, the less a slower attacker can catch up, the more exponentially it decreases. To compensate for increasing hardware performance and time-varying interest in operating a working node, the proof-of-work difficulty is determined by a moving average, which is an average number of blocks per hour. If they are generated too fast, the difficulty will increase.
The steps of network operation are as follows:
New transactions are broadcast to all nodes.
Each node collects the new transactions in a block.
Each node works to find hard-proof of work for its block.
When a node finds proof of work, it sends out the block to all nodes.
The nodes accept the block only if all in-block transactions are valid and not already issued.
The nodes express their block acceptance by working to create the next block in the chain, using the hash of the current block as the previous hash.
Generally, Knots assume that the longest chain is the correct one and work to extend it. If two nodes simultaneously transmit different versions of the next block, some nodes might receive one or the other version first. In this case, they work on the first one which received them but save the other branch in case it gets longer. The tie is broken when the next proof of work is found, and a branch gets longer; the nodes working on the other branch will then switch to the longer one. The broadcasting of new transactions does not necessarily have to reach every node. As long as they achieve many nodes, sooner or later they will be taken up in one block. Block emissions are also tolerant of lost messages. If a node does not receive a block, it will request it as soon as it gets the next block and recognizes that it is missing one.
Counos Coin Block Explorer