This is for developers.  For end users, you will double click the icon and the wallet will pop up.

The bitcoin wire protocol is so complicated, no one knows how it works. I am leaving documentation on the Skycoin wire protocol that developers need to build applications.

Development Update:

The "services" architecture prototype is done.
link: https://github.com/skycoin/skywire/blob/master/poolExample2.go

Raw Socket/Connection Pool:
https://github.com/skycoin/skywire/blob/master/poolExample0.go

Connection Pool with Dispatcher Helper and message serialization/deserialization:
https://github.com/skycoin/skywire/blob/master/poolExample1.go

Services Architecture Prototype:
https://github.com/skycoin/skywire/blob/master/poolExample2.go

Each code example is more complex/higher level than the previous one.

A channel is like a port and each application/service receives messages on a channel. Each service has an object holding state and a set of messages (golang structs) it can receive and send, which are registered at service initialization. When a message is received, the Handle() message is called on the message.  Service have an OnConnect and OnDisconnect callback.

Channel 0 is reserved for a special service that initiates connections between other service and offers service introspection. The service on channel 0 will receive a connection/disconnect for all connecting/disconnecting clients. The channel 0 service mediates connections between services on different hosts.

In this example there are two services, SkywireDaemon (channel 0) and TestServiceServer (channel 1). A connection is created between the connection pools and SkywireDaemon is used to send a ServiceConnectMessage. The remote peer responds to the message and a connection between the TestServiceServer instances is made. This triggers the OnConnect callback on TestServiceServer. Then a TestMessage message is sent via the TestServiceServer instance and the Handle() method is called on the message on the receiving end.

You can run the example with `go run poolExample2.go`.

Blockchain synchronization and transaction relay will be exposed as "services". The service daemon (channel 0) will have functionality for finding peers for services (DHT, PEX), maintaining peer lists and handling connection timeouts.

This is a framework for creating distributed, peer to peer applications on the Skycoin Wire protocol. The top level will create a service daemon, import the desired services and then associate them with the service manager. This architecture enables extensibility through third party applications. This also enables multiple service server instances to be instantiated in a single daemon process, enabling clients to sync multiple blockchains with a single daemon and connection pool (important for personal blockchains and Obelisk servers).

>You would need a wallet that has an inherent market for that. Or would you just allow users to hold all kinds of coins in the one wallet and let them then spend whatever coin is required at a given exchange rate?

We are able to expose exchanges as a Skycoin "service" in the wire protocol. There will be a single API and multiple exchanges implementing the API. Any exchange that runs an exchange service will be discoverable and automatically usable by the wallet. This is part of the "Gateway Protocol".

>. What development time did you plan for all this?

Personal blockchains are done.
- https://github.com/skycoin/skywire/blob/master/chaintest.go
- https://github.com/skycoin/skywire/tree/master/src/hashchain

The only thing left is the wire protocol for replicating the chain.

Exchange service is part of the "gateway protocol". The gateway protocol requires coin launch and several other components under development.

> Ethereum

We received pull request from them and they resolved the gmp dependency bug we had for OSX, so I am assuming they are using some of our libraries. Not too familiar with the code base. There are a number of golang coins in development and the toolchain is evolving faster than the Bitcoin mainline tool chain.

Yes. Skycoin starts with security and usability. Skycoin eliminates the waste of mining and eliminates the 51% attack threat. Skycoin fixes signature malleability, hash collisions in coinbase outputs and several flaws in Bitcoin.

Then Skycoin adds a new, more usable wallet and features to make it easier to use than Bitcoin.  For instance, if you have Dogecoin in your Skycoin wallet and a merchant wants Bitcoin, you hit send and it will convert the Dogecoin to Bitcoin at an exchange at market rate and send the coins to the address. We are able to do conveniences like that. We want to support the major coins in the wallet and want to have receipts, messages and other improvements that streamline usage.

Then Skycoin is focusing on applications that drive adaption and utilize the coin. The mesh network is something we can get working quickly and see if it gets adaption. However, it just one application that we are working on. Skycoin is really an application stack and ecosystem.  Ethereum and several other projects are already using libraries that were developed under the Skycoin project.

Another example, Ethereum offers the ability to do computations in the blockchain and the Skycoin wire protocol is gradually adding support for "personal blockchains". So instead of having one global blockchain, each person can have their own blockchain, which is cryptographically secured and which the people who need the chain replicate. So it may end up making more sense to embed Ethereum's contract system and scripting language in "local" chains instead a single global chain (which can become bloated) and the moving assets between chains.  This could be the basis for an open transactions style crypto-securities system.

This is an example of a personal blockchain: https://github.com/skycoin/skywire/blob/master/chaintest.go

You generate a public key and only the person with the private key can mint new blocks, but everyone can replicate the chain if they know the hash of the public key. The block body can be any array of bytes. This is a major set forward for making it easy for developers to create new blockchain based applications.

Skycoin is not just a coin, but a set of libraries and standards.

For hardware:
- Edimax EW-7811Un (good linux support)
- TP-LINK TL-WN722N (external antenna support for long distance directional links)
- Ubiquiti Nanostation routers (1 mile range line of sight, $80 each)
- Ubiquity AirFiber (15 mile ranges, 1.4 Gb/s, $1500)
- TP-LINK TL-ANT2424B 24dBi 60 cm Directional Grid Parabolic Antenna (10 mile range line of sight)

The subsidy will be about $200/access point.

We need libraries in golang for controlling the wifi devices from linux, scanning for networks, connecting to them, disconnecting.

Yes. We are not doing inflation anymore. It is too much work.

We are hiring new developers after the IPO and will be selling coins to pay them. We wont sell off coins faster than the market can absorb and will decrease sell off rate if it affects the price negatively. Sell off rate will be variable.

We may be giving out coins as an incentive to roll out the wifi network, which requires a density of people who are in range of each other. We will put a map online where people can add locations they can setup equipment and will give out 200 Skycoin for confirmed mesh links. We will choose a few test cities and may distribute a few hundred thousand dollars in coins this way.

We have a lot of software to write, so we will be giving out bounties for projects that will drive adaption and will be hiring more developers.  We will also being doing more things after launch to engage the media and get favorable coverage in news outlets catering to groups that would benefit from adaption. We are hiring people to manage these media relationships and so it does not distract from development.

We are pursuing multiple strategies to ensure adaption.  We are looking at two years of work post launch to get to where we want to be.

Just the wallet project, getting support for multiple coins in the wallet, getting an exchange in the wallet, adding messaging and improving the user experience for purchases is going to take a full team a year of work. We are already starting on the third iteration of the wallet GUI, but will postpone major changes until after launch.

The testnet has been running for 3 months and we are confident that the bugs left are minor. I think we can skip testnet.

Someone else can create a dogecoin pool that mines dogecoin and sells them to buy Skycoin. We dont have time to create a pool because there is too much work to do right now.

Development Update:

Extremely boring changes going on.
- wallet GUI  is being fixed to use new RPC
- new repo for wire protocol: https://github.com/skycoin/skywire

Example of Connection pool: https://github.com/skycoin/skywire/blob/master/poolExample0.go
Example of Connection pool with message handler: https://github.com/skycoin/skywire/blob/master/poolExample1.go

We are moving towards a "service architecture" for networking. You have a connection pool, which manages connections to multiple peers. Each peer is running multiple "services" they advertise. Services communicate over "channels" on a physical connection. Channel 0 is used for QoS, initiation, teardown and service metatadata.  Service peers are found through DHT (distributed hash table) and PEX (peer exchange).

Blockchain downloading/replication is a service, transaction relay is a service. Darknet routing, Darknet relay and off-blockchain transactions are a "service". Distributed exchange will be a service. Messaging will be a service.

Node identities will be authenticated later, but system has not been finalized yet. The identity system will make the service architecture IP address independent. You will be able to find, connect to and message peers from the hash of their public key. Messaging service will offer asynchronous communication between peers by pubkey hash (essentially skycoin addresses).

The messaging system will let your wallet contact the merchant, generate new unused addresses for a transaction and give you a signed receipt for the transaction from the merchant. It will also enable invoices for reoccurring payments, such as for VPS services. Merchants will be able to send shipping confirmations and other information over the messaging channel. This will be major improvement for usability.

We will be assigning development bounties for services like "folder syncing" between computers. We want service that allow users to rent out their disc space and bandwidth to third parties for Skycoin. The system has to do something useful, that people will pay coins for and which does not create a botnet.

Roadmap:

Coin Launch Requirements:
- Blockchain replication ported to Skywire repo using new service architecture
- Transaction relay ported to Skywire repo
- Blockchain database pulled out from skycoin/src/visor and skycoin/src/blockchain

Darknet Launch Requirements:
- darknet relay node service
- darknet routing node service
- golang library for controlling USB wifi devices and initiating connections

We are going to get coin done first, launch. Then work on Darknet, then go back and finish Obelisk.

We have some major announcements, but will wait until after launch.

One developer merged in the new wallet RPC and the wallet GUI developer has not updated the wallet to use the new RFC yet. There is a --web command line option for running GUI in browser, for debugging. Its better for development than the QT client. You can inspect the javascript and see the errors.

The new wallet JSON interface allows loading and using multiple wallets in the same client, but broke the wallet GUI.

update: wallet dev will fix it tomorrow

Most of the work in last week has been in the new wire protocol repo. Should be on github soon.

Skycoin License:

The license will be a standard open source license. Current license is
- you can distribute code for non-commercial use
- you can modify code for non-commercial use
- You agree to copyright assignment under the to be determined open source license
- you grant perpetual license to use, distribute and modify any contributed code

We might have terms like "no forking coin without permission for 24 months after date X" and then license is MIT or GNU after that. We have already had to remove build scripts from the repo because someone tried to fork and launch the coin before us.

Skywire: Skycoin Wire Protocol:

The wire protocol is almost done.

The new connection pool has "channels" (uint16). Each channel expose a "service" (a thing that sends/receives packets within a channel). Each connection between two peers in the connection pool can support multiple services running over the same TCP connection.

This is implemented by a connection pool and length prefixed messages with a "dispatcher" that handles the messages for each channel. Raw bytes can be read and written from channels, but gnet has a default dispatcher that allows you to register structs as network messages. When a message is received, the .Handle(...) method of the corresponding struct is called on the receiving end. The struct fields on receiving end are already set to the values that were transmitted. This makes building distributed P2P services very easy (summary: you put data in struct, hit send and on receiving end the .Handle() function is called on the struct).

Current services:
- block chain relay server
- transaction relay server
- emergency messaging server
- obelisk node server

There are tools for finding peers running particular servers using DHT (distributed hashtable) and exchanging peer lists between peers (PEX, peer exchange). Example, If you have a blockchain genesis hash, you can use the hash to find peers running a blockchain server for that chain and download the blocks from them.

If a user wants to create a new, more efficient system for blockchain replication, they can create their own service/server and put it on github and other people can use it. Its extremely modular and not monolithic like the Bitcoin wire protocol.

Darknet Service Example:

This service architecture is the starting point for many of the darknet services. I will write a tutorial with code snippets, for creating a new darknet service.

This is a toy example for creating a distributed exchange through the Skycoin wire protocol, in a few hundred lines of code. You define structs for "check balance" and buy/sell commands and order book listing command. You run the exchange service and it automaticly connects to peers running the exchange service. You say "I want to sell 5000 dogecoin for 1 Skycoin", someone takes the order. The service negotiates the receiving address, receives the Skycoin and sends the 5000 Dogecoin.

That is a fully functional distributed exchange, but does not address cheating. What if you send coins, but do not receive coins? You could
- use a white list and only send coins to trusted exchange services (simpliest and works right away)
- use a more complicated protocol

To prevent cheating you might both agree "I will send 5000 dogecoin to address A within one hour. You will send 1 skycoin to address B within one hour". You both sign the hash of the agreement. If the person does not send the coins, you publish the transaction to Bitcoin talks and everyone can verify it and prove he is a scammer.

Or You both have coins in escrow with mutually agreed upon third party C. The signed agreement is given to C. If one side fails to execute the agreement, the amount is taken out of escrow and C executes that person's side of the agreement at current price.

Skycoin has a protocol under development, called the "gateway protocol" that will simplify these types of transactions. This is an outline for doing a simple distributed exchange with a "raw" service on top of what is implemented right now.

What is Obelisk?

Obelisk is what makes Skycoin, Bitcoin 2.0. Obelisk is a sustainable alternative to proof-of-work. Obelisk is a system that replaces proof of work for blockchain consensus and eliminates the possibility of a 51% attack.

Obelisk was inspired by academic research into adversarial distributed time-stamping and algorithms such as Ben-Or's, Paxos, and the Castro-Liskov PBFT algorithm. Obelisk is a new solution to the Byzantine Generals problem which offers strong mathematical security guarantees, even when the majority of nodes are hostile.

What is the Skycoin Darknet Project?

The Darknet project is the first major Skycoin application.

https://github.com/skycoin/darknet

How does Obelisk Improve on Bitcoin:

Obelisk and specific design decisions may allow Skycoin to achieve transaction confirmation times as low as four seconds, without compromising security.

Skycoin does not waste electricity or consume exponentially growing, unsustainable amounts of electricity unlike Bitcoin.

Skycoin cannot be 51% attacked. No matter how much money or hashing power an adversary has, they cannot reverse transactions.

Obelisk Technical Aspects:

Obelisk allows consensus on multiple concurrent branches simultaneously so the network does not stop for consensus. For instance, if there are two outstanding candidate branches in the possible consensus set and both branches have executed your transaction, your transaction is effectively executed and the outputs available for spending regardless of the future consensus decisions. The output hashs only depend on the input and the transaction hash, not upon the block the transaction was executed in.

The chance of a blockchain fork at block X in Skycoin approaches zero exponentially quickly in the number of blocks minted on top of X. Therefore increasing block rate improves Skycoin security (up to a point) where as increasing block rate decreases Bitcoin security (increases orphan rate). In Bitcoin, the effort required to fork at a particular block is the network hash rate times the time since the block. Decreasing the time between blocks leaves this number constant. Forking a chain with 10 blocks one minute apart requires the same level of effort as forking a chain with one block 10 minutes apart.

In Skycoin each Obelisk node has a "public broadcast channel" which timestamps block announces and counter timestamps the arrival of messages from other Obelisk nodes (construction of public broadcast channel is in Obelisk paper). If a node attempts to revert network consensus and fork the chain at a earlier block, the other nodes can prove mathematically that with high probability the block did not exist (was not announced to network) at the time the node claims to have made its local consensus decision in favor of the block.

Its possible to construct an unforgable mathematical "proof of fail" using the signed timestamps. The proof can be verified by third parties, showing the node is retroactively claiming consensus for a block that was not announced to the network at time it claims consensus. Any node receiving the proof would sever its trust (public broadcast channel subscription) relationships with the cheating node and furthermore you can safely sever trust relationships with any node that fails to sever trust relationships with the cheating node.

Ripple assumes that the nodes running the network can be trusted. Skycoin assumes they are cheating, detects the cheating and bans them.  Skycoin uses a "relational consensus" model, similar to Ripple but Skycoin should not be compared to Ripple because Ripple does not meet the Bitcoin criteria for decentralization.

Yes. You have it working! The wallet gui is running a GTK window that embeds webkit. The wallet is HTML/Angular with a localhost golang webserver. That is what you are looking at. The wallet uses the JSON interface to check balances and do sends.

- We dont have transaction history yet. You can check balance and do sends using the unspent output set, but transaction history requires parsing old blocks and putting it in a database.
- The wallet RPC is currently being updated (in branch) to support multiple wallets and the new deterministic wallet seeds.
- Then the wallet code will be updated to match the new RPC before launch
- You can run a local blockchain, but the global testnet blockchain is not running right now.
- There is a tool in ./compile/test-coverage that generates an HTML coverage test across repo
- ./test.sh runs the unit tests for each module
- you can generate addresses and test out deterministic wallets with ` go run ./cmd/address_gen/address_gen.go -a -n=5 -seed="test" `. This tool needs some work. This prints 5 (pubkey, seckey, address) pairs generated from wallet seed "test"

Technically, we can launch testnet right now. Everything is working.  There are a few changes I wanted to make however
- new wire protocol
- reduce number of command line options
- simplify module interfaces and take steps towards requirements for Obelisk integration
- hardcode genesis block parameters into source instead of using configuration files
- document JSON RPC that exchanges need

After launch we have to
- work on darknet
- language translations for wallet
- improvements to connection pool and wire protocol required for Obelisk
- work on Obelisk and achieve full decentralization
- blockchain explorer and transaction history
- blockchain database module (for storing and querying transaction history)
- benchmarks for blockchain parsing

The priorities are
1. Get blockchain running and windows, osx and Linux binaries released
2. Skycoin Darknet v0.2 Running
3. progress towards Obelisk implementation

The user community is giving a lot of support. We have volunteers working on the wifi controller library for the darknet and others have made significant contributions to the darknet design. Others have donated Bitcoin to pay for build and testing servers and others are working on a Docker wrapper for Skycoin node deployment and working on the Chinese wallet translation.

The code base is becoming very clean and modular. Skycoin will be much easier for new developers to work on and improve compared to the Bitcoin source.

Update:

The new wallet and wallet rpc branch has been merged into the main branch.

Development Update:

The new wire protocol is more work than expected. Instead of delaying launch by two weeks, to address these issues I am hacking together something that will get the network running.

Multiple software components need to be be refactored.
- Daemon needs to be extended to support multiple connection pools with independent peer exchange and using a common listening socket
- gnet needs to be modified to support an introduction packet
- gnet packet handling callbacks need to be embedded in the gnet object instead of globals, to allow multiple gnet instances in the same application
- daemon DHT functionality for peer bootstrap needs to be abstracted to allow for retrieving bootstrap peers for multiple hashes.
- the hashchain replicator wire protocol needs to be designed and implemented
- the blob and hashchain replicators need to be abstracted on top of the new connection pool

Update:

The new wire protocol is now in its own repo as a library. github: https://github.com/skycoin/sync

run.go is a simple example of spawning two instances and replicating blob data between the instances. Writing tech demo for synchronization of a cryptographically authenticated blob data and running a webserver off the synchronized data.

Development Update:

This is overview of the Skycoin checkpoint system. The checkpoint system addresses the exponential growth of the blockchain, by keeping the data required to run a full client to less than one gigabyte. This was a core design objective for Skycoin, to enable usage on mobile phones.

The checkpoint system allows users to check balances and do transactions without downloading the full block chain. The client only requires a copy of the unspent output set and the blocks since the unspent output set to parse the next block.

1. Every 16384th block will be referred to as a "checkpoint block"
2. Every 16384 blocks (every 68 hours), each obelisk node will publish and sign
- the SHA256 merkle tree hash of the unspent output set
- the SHA256 merkle tree hash of the blocks since the last snapshot
3. Upon reaching a checkpoint block, each client will verify its state against the checkpoints published by the obelisk nodes it is subscribed to
4. The checkpoint at block 2*16384 is for blocks 0 to block 16384.
5. If snapshots are enabled, clients will download the UxSet and blocks since the last checkpoint block. The client will be fully functional at this point and then will begin to download the history since the first block.
6. Verification against Checkpoint Blocks will be enabled by default, but use of snapshots will be disabled for security unless explicitly enabled.
7. High security applications such as exchanges are recommended to disable snapshots and parse the blockchain from the genesis block.
8. If there is a discrepancy between the checkpoint hashes for the nodes a user is subscribed to, the user will be alerted and additionally security measures (such as disabling coin sends) may be put in place until the situation is resolved.

Unspent Output Set Hash:
- Additionally, for each block the unspent output set is hashed and the first 4 bytes of this hash are included in each block. This is a checksum hash and is designed to be constant time for addition/removal of outputs and not designed to be a cryptographic hash. This hash detects non-determinism and bugs in the unspent output state before they can cause blockchain forks.

Skycoin Blockchain Security:

We have made progress on the design of Obelisk. We are evaluating Obelisk under an attack scenario where 90% of the nodes are malicious. We have determined that a severe sibyl attack may slow down block consensus or slow down execution of specific transactions but cannot fork the blockchain earlier that a few blocks into the past (no 51% attack, no double spending). The success rate of blockchain forks in Skycoin, decreases exponentially quickly in the number of confirmations a block has (where as Bitcoin attack difficulty increases approximately linearly in number of confirmations).

An attacker who dominants the Bitcoin hash rate can mint blocks with 0 transactions (slow down network) and 51% attack (revert previously executed transactions). Skycoin does not use mining and an attacker using a colluding majority of Skycoin Obelisk nodes is only able to slow network consensus and transaction processing, but cannot revert previous transactions.

Development Update:
- wire protocol almost done
- deterministic wallets RPC almost done (in branch)
- fixing wallet GUI to match new RPC
- windows, OSX and linux build scripts are done

We are working towards a launch where the coin is trading as soon as possible. After launch, there is still work to do.

Yes. We should have windows binaries.

Notes:
- If you want to run from source, linux is much easier than windows, because windows requires dealing with mingw configuration.
- When golang 1.3 comes out, we will be cross compiling the windows binaries from linux directly
- We are looking into using docker for deployment and testing
- 64-bit is highly recommended
- some people are getting errors because golang is not detecting changes to imported modules correctly. ./compile/clean-static-libs.sh fixes this problem by clearing out the cache

Development Update:

We are compiling binaries for the testnet. Will release binaries and instructions for running testnet from source. You will be able to get testnet coins by posting address in github thread.

Development Updates:

We are updating the Skycoin wire protocol. This is the last thing on checklist before launch.

=== Blob Replicator ===

The Blob Replicator is done. Blob replicator is used for transaction replication and the emergency messaging system.

- https://github.com/skycoin/skycoin/blob/master/src/sync/blob_replicator.go

This uses a gossip protocol to replicate data among a swarm of peers.
- A blob is a series of bytes. The id of a blob is its SHA256 hash
- On connect a peer receives a list of all the hashes of the Blobs the peer has.
- the client requests any blobs peers have that the local client doesnt have
- When a client downloads a new blob, it announces the hash of the blob, so other peers know it exists
- There is a callback function that determines if blob is valid, should be ignored or if peer sending the blob should be kicked
- Blobs are only replicated if they  are "valid" and the callback function judges validity

Uses of blobs include
- emergency messaging system (criteria: blobs contain valid signature)
- transactions (criteria: transactions must be valid and meet various criteria)

Example of using Blob Replicator:
https://github.com/skycoin/skycoin/blob/master/run.go

=== Request Manager ===

Request manager is under development and almost done. Request Manager rate limits requests and is used to protect against DDoS and Sybil attacks.

https://github.com/skycoin/skycoin/blob/master/src/sync/request_manager.go

Request Manager
- queues up requests for data and spreads them over times
- keeps tracks of what requests are in progress
- limits requests per peer
- disconnects clients who are not responding to requests
- disconnects clients who send data that was not requested
- stores information for detecting DDoS and Sybil attack nodes
- kicks nodes that are slow, to speed up blockchain downloads

=== Hash Chain Replicator ===

This is like the Blob Replicator, but used for block chain replication. This component is used for downloading the blockchain and for Obelisk.

This is last component of the wire protocol before launch.

Development Updates:

- fixed coin hour calculation bug. Each coin is 1 million "droplets". Due to integer rounding error, user would not receive coinhours from output s with a balance less than one million droplets. Bug is fixed.
- Coinhour calculation is now based upon the block time of the previous block, not the block the transaction executed in.
- Unit tests in /src/coin are fixed
- RFC for wallet is being redone to support multiple coin wallets
- design for emergency messaging system is done
- more developers have joined the darknet/meshnet project

Launch Checklist:
- a new wire protocol is being developed for transaction propagation and block replication.
- refactoring of /src/blockchain and /src/visor

Development Update:

The hash function for Skycoin deterministic wallet generation is finished. We believe our new deterministic wallet hash function is the most secure hash function against GPU and ASIC brute forcing to date. We are using a new hash called "secp256k1 Hash" that combines SHA256 with elliptic curve signature operations.

Secp256k1 Hash Implementation:

1> SHA256 seed value
2> Compute deterministic private key, pubkey pair from seed value
3> Generate deterministic secp256k1 signature from seed and generated private key
3> Append signature to seed and compute its SHA256 hash

IPO Update:

The IPO may be drawn over a week, instead of being a single day period. The IPO may look like this
- you go to website.
- you put in a skycoin address where coins will go
- you put in a return bitcoin address  where coins that could not participate in IPO will be returned
- you receive a deposit address to send Bitcoins to
- the three addresses will be concatenated, hashed and signed with a special IPO Public key, so that they can be verified
- each day over the week long IPO, the Skycoins will be deposited into your address
- the Bitcoin that did not participate in the IPO will be sent to the return address, minus 0.0001 transaction fee

Privacy
1. The output address and coin amount for each Skycoin address that received coins in the IPO will be published
2. The input and return address will not be published unless the user chooses to publish this information.
3. If you did not receive coins or coins were not refunded, you can publish your signed address tuple and it can be publicly verified

We may do a one day mock IPO with testnet coins, so everyone can see how it works.

Software Update:

The design of Obelisk is finalized. All the pieces come together and its a major milestone for cryptocoins. We believe that Skycoin will be the most secure, most difficult to attack non-mined cryptocoin to date.

Changes:
- there is now list of things for developers to do https://github.com/skycoin/skycoin/wiki/SOFTWARE-DEVELOPERS-CLICK-HERE
- we introduced proof of work and difficulty re targeting to keep block production rate constant. As the network scales from 10 nodes to 100,000 we need to keep the block rate constant and prevent it from growing linearly with the number of nodes. This minimizes the number of decisions and rounds Obelisk needs to converge to network consensus. Proof of work will be used for block minting, but not for block consensus. There will be no reward for block minting. Malicious blocks (blocks with no transactions or few transactions) will be weighted against, to deter abuse. The proof of work is not in the block headers, but occurs at a higher level that wraps the blockchain. This makes it more modular and easy to swap out and modify without causing a hardfork.
- we proved that probability of a block fork under Obelisk approaches 0% exponentially quickly with block depth.
- transaction and block replication in /src/daemon are being abstracted into a library. The emergency messaging system and transaction propagation will use "blob replication". Blockchain and obelisk replication will use "hash chain replication". This will make the system more modular and make improvements to block and transaction propagation easier.
- we are working on builds for testnet client. Obelisk is not implemented yet, but you will be able to run client and send coins around and hunt for bugs
- There is a massive refactor going on. Replication functionality  in /src/daemon is being moved into /src/sync. /src/visor functionality is being moved into /src/blockchain and the top level of Skycoin is being moved, to make changes required for Obelisk integration.
- /src/coin and the cryptography libraries are "done".  The changes to this part of program will be minimal going forward.
- we are finalizing the JSON RPC for exchanges and wallets