A purely peer-to-peer version of an electronic payment method would allow online payments to be sent from one party directly to another without going through a financial institution. Digital signatures are part of the solution, but the main benefits are lost if a trusted third party continues to be required to prevent double-spending. We suggest a solution to the double-spending problem by using a peer-to-peer network. The network timestamps transactions by hashing them into a continuous chain of hash-based proof of work, creating 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 also as proof 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 were away.
Very similar to bitcoin algorithm, more than 16.800.000 coins already mined and less than 4.800.000 coins would be mining by people around the world.
Counos Coin has no central authority or middlemen. But support by a professional team to make it very useful in near future.
We define an electronic coin (coin) as a chain of digital signatures. Each owner transfers the coin to the next one by digitally signing a hash of the previous transaction and the next owner's public key and appending it to the end of the coin. The recipient of the payment can verify the signatures to verify the chain of owners.
The problem, of course, is that the payee cannot verify that one of the owners has not duplicated the coin. One standard solution is to introduce a central, trustworthy 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 issue, and only Coins issued directly from the Mint can be trusted 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 way 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 know all transactions. In the mint-based model, the Mint recognized all the transactions and could decide which ones 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 a Usenet post [2-5]. The timestamp proves that the data existed at this point, obviously, otherwise, there would be no hash of them. Each timestamp contains the previous timestamp in its hash and forms a chain where 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 the newspapers or Usenet posts. The proof-of-work involves finding a value where, when it is 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 the hash of the block the necessary zero bits. After the CPU has put in enough work to do the proof-of-work, the block cannot be changed without rerunning the job. Since later blocks are chained to it, the work to replace the block would involve recreating all subsequent blocks. The proof-of-work also solves the problem of determining the majority in majority voting. If the majority was 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 was invested. If a majority of CPU power is controlled by honest nodes, the straight chain will grow fastest, 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. We will demonstrate later that the more blocks that 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 increases.
The steps to operate the network are as follows:
- New transactions are broadcast to all nodes.
- Each node collects the new transactions in a block.
- Each node is working 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 transactions in it are valid and not already issued.
- The nodes express their acceptance of the block by working to create the next block in the chain, using the hash of the current block as the previous hash.
Knots always assume that the longest chain is the correct one and are working 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 who 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 that worked 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