OpenCoin

The opencoin project is about "digital cash". We develop a protocol to use the original idea of electronic cash in daily live. For this we also develop a system consisting of minting software, wallet software and everything that is necessary to have a system for anonymous electronic transactions.

opencoin defines standards and provides an implementation around the blind-signature system as invented by David Chaum, known as electronic cash / digicash. The software and specs are opensource under a GPL License.

Reference Etherpad: http://titanpad.com/opencoin2012

PROJECT GOAL:
-------------
The goal is to develop a foundation for the issuer service (but not the functional service itself). The issuer service expose a REST API. For the scope of this project it consists of two simple interfaces for demonstration purposes only:
- A GET interface to allow clients to retrieve coins in JSON format
- A POST interface to allow clients to redeem/send coins in JSON format

Optional: Coins are stored in a SQL database (via squeryl library)

Further Requirements:
---------------------
- Coins have the following structure: case class Coin(type: String, value: Int)
- The deliverable should contain a documentation which describes how the system is deployed to allow future updates of individual software components. For instance in the future a newer Finagle server version may be used and the documentation should describe step by step how to integrate it with the other libraries and the actual source code.
- Source code should be documented as well.
- Test cases should be performed and documented. Optional: ScalaTest may be used for testing.

To be used technologies:
------------------------
- Scala programming language
- Twitter's Finagle server
- SBT build tool
- Optional: Eclipse IDE is recommended
- Optional: Coins are stored in a SQL database via squeryl library

The following links might be useful to understand Finagle's REST capabilities:
https://github.com/robi42/heroku-finagle-rogue/blob/master/src/main/scala/server.scala
https://github.com/twitter/finagle/blob/master/finagle-http/src/main/scala/com/twitter/finagle/http/path/Path.scala

BACKGROUND:
-----------
This information is optional background information about the project but doesn't describe the scope or functionality of the current project goal!

Open Coin introduces versatile digital cash which can be used similar to
ordinary cash but allows a higher flexibility. The cash is issued by a
central service and you can think of it as digital coins which hold a
certain denomination. Each coin is basically a long string like
6A09E317F4BCD... which can be stored locally and transferred between
customers in a peer-to-peer manner. Actually the central issuer doesn't
perform the transaction itself but is only involved to ensure the
validity of the coins and to prevent fraud by double-spending a coin.
This approach is based on David Chaum's blind signature algorithm in
which cryptography protects the coins and ensures the anonymity of the
customers. This algorithm was invented 1983 and since then has been
analyzed exhaustively by cryptographers and proven to be secure.
Since our central issuer service is not directly involved in the
transfers, coins can be exchanged peer-to-peer via social networks,
e-mail, chat, web portals, and even via portable USB drives.

"In cryptography a blind signature as introduced by David Chaum is a
form of digital signature in which the content of a message is disguised
(blinded) before it is signed. The resulting blind signature can be
publicly verified against the original, unblinded message in the manner
of a regular digital signature. [...] An often used analogy to the
cryptographic blind signature is the physical act of enclosing a message
in a special 'write through' capable envelope, which is then sealed and
signed by a signing agent. Thus, the signer does not view the message
content, but a third party can later verify the signature and know that
the signature is valid within the limitations of the underlying
signature scheme." (Wikipedia)

1. The sender Alice retrieves coins from the issuer in a way that the
issuer can verify its validity but doesn't know which particular coin
(serial number) Alice has.

2. Alice sends the coin to the receiver Bob.

3. To verify the validity of the received coin, Bob sends the coin to
the issuer.

4. The issuer verifies the coin and because of the blind signature
algorithm, is able to say whether a particular coin is valid or not but
doesn't know whom the coin was issued to in the first place. If the coin
is valid the issuer mints a new coin for Bob in exchange for the
received one and sends it back. The issuer stores the received coin in
the Double Spending Database to prevent its later reuse. In general this
mechanism prevents fraud by double spending money.

5. Bob receives the new coin from the issuer and marks the transfer as
complete and verified.
It is important to understand that technically steps 3 and 4 are a coin
exchange but on the user interface level these steps are simply the coin
verification and are only raised to Bob's attention in the error case.
Even though they may sound complicated, in the usual case these steps
are hidden from the user Bob at all.