From Open Transactions
Revision as of 19:12, 5 June 2013 by Unknown user (talk) (Created page with "**What is OPEN-TRANSACTIONS?** * Open-Transactions is an Use Cases, financial crypto, Sample Cash and transaction [[library|List of Classes...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)
Jump to navigation Jump to search
    • What is OPEN-TRANSACTIONS?**
 * Open-Transactions is an Use Cases, financial crypto, Sample Cash and transaction List of Classes.
 * Open-Transactions includes a **API**, a working **OT-Server**, a **TestGUI** (in Java) and a opentxs wallet utility.
 * Open-Transactions features: a large variety of financial instruments, markets, basket currencies, unforgeable account balances, **untraceable digital cash,** destruction of account history, http://iang.org/papers/ricardian_contract.html, Smart Contracts (scriptable clauses), and more.

    • WHAT DOES IT DO?**
 * **Open-Transactions allows users to issue and manipulate digital assets.** 
 * Any issuer can sign and distribute new Sample Currency Contract in order to create new digital asset types.
 * Users may create many _pseudonyms_ (public keys), each of which may own _asset accounts_ of various types, on OT servers.
 * Users can operate **"cash-only"** _(without accounts)_ for maximum anonymity, using **Sample Cash**.

("Test-GUI with Screenshots":https://github.com/FellowTraveler/Moneychanger) NEW: GUI Mock-Ups! (first draft) "standard mode":https://www.fluidui.com/editor/live/preview/p_8ZN0r9Pbp2XzPC7yL3lDFw5lW2L7vEye.1343824445082 | "advanced mode":https://www.fluidui.com/editor/live/preview/p_XcN9TmQ5FItuPr5QctxES2XfAhinsVPp.1343659566990

"Install via apt-get (click here)":http://www.reddit.com/r/Agorism/comments/19p6oa/how_to_issue_your_own_currency_using/

    • Radio Interview**

"Part 1, courtesy of AgoristRadio.":http://agoristradio.com/?p=234 "Part 2, courtesy of AgoristRadio.":http://agoristradio.com/?p=246

Bitcoin donation address: @[email protected]

IRC: #opentransactions at irc.freenode.net

    • Video Walkthru**

"Video 1 posted by J. Orlin Grabbe.":http://vimeo.com/28141679 "Video 2 posted by J. Orlin Grabbe.":http://vimeo.com/28142096

"New videos!":http://open-transactions-tv.github.com/

 * Users can transfer digital assets _securely and provably_, with Triple-Signed Receipts signed by all parties.
 * **Even an OT server cannot change balances, or forge transactions--since it cannot forge your signature on your receipt.**
 * Open-Transactions supports a range of **Instruments** such as account transfer, **Sample Cheque** and vouchers (aka "cashier's cheques" or "banker's cheques"), in addition to cash.
 * These instruments are all analogous to the same financial instruments that we all use at normal banks today. Everyone already has an intuitive understanding of these financial instruments, because we use them regularly in our normal daily lives.

 * Open-Transactions also implements higher-level, **contract-based transactions** such as **payment plans** and **markets with trades**.
 * The Markets on Open-Transactions support _market orders, limit orders, fill-or-kill orders, day orders, stop orders, and stop limits_, just like trading on a real market.
 * **Basket currencies** are also supported, as well as payment plans (recurring payments.)
 * NEW: Smart Contracts: Multi-party agreements with scriptable clauses... including hooks, callbacks, internal state, etc.
 * NEW: Client-side scripting:  @#!/usr/bin/env [email protected]
   The entire (mostly) high and low level OT API is available within your scripts.

 * All of this is accomplished in such a way that all parties are able to _prove_, at all times, _which transactions have cleared and which instruments are authorized_, **without having to store their entire transaction history**, but instead by merely keeping the **last signed receipt**.
 * Without the special mechanism that makes this possible, _all parties would otherwise be forced to store all receipts forever_.
 * Nyms and Asset Types have consistent IDs across all OT servers, since the ID is formed by hashing the relevant contract or public key.

The real beauty of Open-Transactions is the as-yet-unwritten future of _new ideas_ that you can build with it, and the future liberty and security of your children that you can help to protect by doing so--in a very real and tangible way.

__The vision is not of a central server that you must trust.__ __Rather, the vision is of federated servers you don't have to trust.__

The server itself is a Transactions in the cypherpunk tradition. In more detail:

 * Many **financial instruments** are supported: Users can write **cheques**, purchase **cashier's cheques** ("vouchers"), and withdraw in **Sample Cash**. The software uses Chaumian-style, blinded tokens courtesy of the *"Lucre":http://anoncvs.aldigital.co.uk/lucre/* library by Ben Laurie.
 * It's like **PGP FOR MONEY**. The idea is to have many cash algorithms, not just Lucre. I’d like to add Chaum’s version, Brands’ version, etc. So that, just like PGP, the software should support as many of the top algorithms as possible, and make it easy to swap them out when necessary.
 * User accounts are **pseudonymous**. **A user account is a public key**. (This is like http://pktp.co.cc/ by Andrew McMeikan.) You can open as many user accounts as you want. *Full anonymity* is possible only for "cash-only" transactions (where users only perform token exchanges, and do not open accounts), whereas *pseudonymity* means that transactions can be linked to the key that signed them. (While the real life identity of the owner is hidden, continuity of reputation becomes possible.) *See full-color diagrams linked above*. 
 * **Any user can issue new digital currencies** and digital asset types, by uploading the new **Sample Currency Contract** to the server. (This functionality is comparable to http://www.systemics.com/docs/sox/overview.html by http://financialcryptography.com/.)
 * **Users can open asset accounts of any type.** You can have as many as you want, associated with each user account. (See http://loom.cc/ by Patrick Chkeroff.)
 * **Triple Signed Receipts**. *On OT, entities are able to conduct transactions, verify instruments, _and_ provably agree on current holdings via _signed receipts_, all without the need to store any transaction history.* An _"asset account"_ on OT is not according to the traditional sense of the word (an account normally being thought of as, "a list of transactions, with a balance, used in double-entry bookkeeping.") While the word "account" makes things easy to understand, _an "asset account" on OT exists only in the mind of the account holder himself_. He simply asks the server to agree with him that it exists, and to provide him with a signed receipt to that effect. In the user interface, OT is able to mimic the _account metaphor_, making usage intuitive, even though *no actual "account" exists, or need be stored on either side, _other than the signed receipt itself!_* (See Bill St. Clair's excellent http://truledger.com/ for an http://truledger.com/doc/plain-english.html.)
 * Open Transactions also features **markets**. Any two asset types can be traded against each other. The markets are full-featured and include **limit orders, stop orders, fill-or-kill, day orders** (date ranges), and **stop limits**.
 * Open Transactions also supports **basket currencies**. Users can define their own, and the server handles the process of exchanging in and out of basket accounts. Baskets are treated by the software like any other asset type, (you can open accounts, transfer funds, withdraw cash, write cheques, and even **trade basket currencies on markets**.)
 * NEW: Smart Contracts: Multi-party agreements with scriptable clauses... including hooks, callbacks, internal state, etc. This concept was originated by Nick Szabo: "smart contracts":http://szabo.best.vwh.net/contractlanguage.html
 * NEW: Client-side scripting:  The entire OT API is now available for use in OTscripts on the client side. Just remember to put this at the top of the file:  @#!/usr/local/bin/ot [email protected] 
 * Open Transactions also supports **payment plans**. Users can sign contracts with each other, and the server will carry out the terms and implement the payment plan. (A future goal is to issue new asset types based on revenue from payment plans--so they can also be traded on markets.) 
 * **Contracts**, in general, are very important to Open Transactions; they are the building block of the entire library. Open Transactions uses a Ricardian-style contract, and all the various instruments, data files, and messages resemble **Sample Currency Contract**. All objects serialize to a string.
 * The philosophy of the software is based around **separation of powers** (issuers and transaction servers being separate entities) as well as the **distribution of risk**. For example, Asset accounts can be distributed across multiple servers, and asset types can be distributed across multiple issuers (via baskets.) Read about the "auditing protocol.":https://github.com/FellowTraveler/Open-Transactions/wiki/Auditing
 * Potential future instruments include: "Real Bills":http://www.goldstandardinstitute.net/2010/06/what-is-a-real-bill/, dividend-paying stocks (the same mechanism can be used as "interest paying bonds") and collateralized debt obligations. (OT supports payment plans, so it would be easy to group tranches of OT's payment plans to pay into a single reserve account, as backing for a new stock offering that could be traded on OT markets.) This is similar to how basket currencies are implemented. Stocks/Bonds would pay shareholders by dropping a cheque into your stock account's inbox.  These features aren't available yet, but they are easy to add given the existing OT infrastructure. 
 * **All communications are secured with OpenSSL.** All messages are also signed and encrypted. All transactions require signatures from relevant parties including the server. 
 * Open Transactions is **open-source**, written in C++, object-oriented, and includes **Native APIs** for **Java, Ruby, Python, PHP, Perl, C, "D":http://www.digitalmars.com/d/2.0/overview.html, C++, Objective-C, C#, Tcl, and LISP.** (Also supporting JRuby, Jython, Scala, Clojure, Groovy, and any other language that works on the JVM.)
 * The software is fully **cross-platform**: **Linux, Mac OS X, FreeBSD, Android, and Windows** are supported with makefiles, project files, and instructions.
 * STORAGE... The library itself is  **storage neutral**, and could be utilized across a variety of different storage systems. All objects serialize to a string, and it is very easy to add support for new storage methods. (Current testserver and testclient use the filesystem with key/value pairs.) **Adding a new storage method is as easy as subclassing OTDB::Storage and overriding a few methods. Use any DB you want.**
 * Messaging... The library itself is **transfer-protocol neutral**, and can be utilized across a variety of different transfer protocols. The default implementation uses the "ZeroMQ library":http://zeromq.org/ for transport. Transport is implemented as a callback function, so it's very easy (a few dozen lines of code) to swap in some other system, if you wish.
 * OT currently supports **MsgPack** and **protobuf** for data packing, though new packers can be added by subclassing OTDB::Packer.

The intention is for this software to be integrated as many places as possible... Games, digital cash wallets, distributed data stores, secure voip apps, anonymous bit torrent networks, mixnets, remailers, nym servers, etc. There are many other potential uses.