A collection about all things Libra, Move & ZuckerBucks - Let's reinvent money with fast and cheap world-wide transfers; let's bank the 1.7 billion unbanked, ...
Moving money around the world should be as easy and cheap as sending a text message (or a photo).
web: libra.org
Libra's mission is to enable a simple global currency and financial infrastructure that empowers billions of people.
This document outlines our plans for a new decentralized blockchain, a low-volatility cryptocurrency, and a contract platform that together aim to create a new opportunity for responsible financial services innovation.
Libra's goal: A stable cryptocurrency built on a secure and stable open-source blockchain, backed by a reserve of real assets, and governed by an independent association.
(Source: Libra White Paper)
Libra is a stable coin backed by a basket of (four?) currencies (USD, EURO, GBP, JPY), and US Treasury securities in an attempt to avoid volatility (and speculation). Facebook has announced that each of the (100?) partners will stake an initial US$10 million, so Libra is backed by US$1 billion of solid currency, on the day it opens.
(Source: Libra (cryptocurrency) @ Wikipedia)
Q: What's a Microlibra? What's the smallest Libra subunit?
A: Libra can be broken into 1 million smaller units, that is, 0.000001 Libra (six digits). The official name for the smallest 0.000001 Libra unit is Microlibra.
Libra Rerseve
- The Official Libra Reserve White Paper, PDF Download (~40k, 4 Pages)
Q: What are the actual assets that will be backing each Libra coin? A: The actual assets will be a collection of low-volatility assets, including bank deposits and government securities in currencies from stable and reputable central banks. As the value of Libra will be effectively linked to a basket of fiat currencies, from the point of view of any specific currency, there will be fluctuations in the value of Libra. The makeup of the reserve is designed to mitigate the likelihood and severity of these fluctuations, particularly in the negative direction (i.e., even in economic crises). To that end, the above basket has been structured with capital preservation and liquidity in mind. On the capital preservation point, the association will only invest in debt from stable governments with low default probability that are unlikely to experience high inflation. In addition, the reserve has been diversified by selecting multiple governments, rather than just one, to further reduce the potential impact of such events. In terms of liquidity, the association plans to rely on short-dated securities issued by these governments, that are all traded in liquid markets that regularly accommodate daily trading volume in the tens or even hundreds of billions. This allows the size of the reserve to be easily adjusted as the number of Libra in circulation expands or contracts.
Mint & Burn Libras
The Libra Association is the only party able to create (mint) and destroy (burn) Libra. Coins are only minted when authorized resellers have purchased those coins from the association with real assets to fully back the new coins. Coins are only burned when the authorized resellers sell Libra coin to the association in exchange for the underlying assets. Since authorized resellers will always be able to sell Libra coins to the reserve at a price equal to the value of the basket, the Libra Reserve acts as a "buyer of last resort."
(Source: Libra White Paper)
Open Identity (Id) Standard
An additional goal of the Libra association is to develop and promote an open identity standard. We believe that decentralized and portable digital identity is a prerequisite to financial inclusion and competition.
(Source: Libra White Paper)
Libra Association, Switzerland, Quai de l'Ile 13, Gèneve 1204.
The Libra Association is an independent, not-for-profit membership organization, headquartered in Geneva, Switzerland.
github: libra
- Libra Core (Testnet Client), github:
libra/libra
Abstract: The Libra Blockchain is a decentralized, programmable database designed to support a low-volatility cryptocurrency that will have the ability to serve as an efficient medium of exchange for billions of people around the world. We present a proposal for the Libra protocol, which implements the Libra Blockchain and aims to create a financial infrastructure that can foster innovation, lower barriers to entry, and improve access to financial services. To validate the design of the Libra protocol, we have built an open-source prototype implementation - Libra Core - in anticipation of a global collaborative effort to advance this new ecosystem.
The Libra protocol allows a set of replicas - referred to as validators - from different authorities to jointly maintain a database of programmable resources. These resources are owned by different user accounts authenticated by public key cryptography and adhere to custom rules specified by the developers of these resources. Validators process transactions and interact with each other to reach consensus on the state of the database. Transactions are based on predefined and, in future versions, user-defined contracts in a new programming language called Move.
We use Move to define the core mechanisms of the blockchain, such as the currency and validator membership. These core mechanisms enable the creation of a unique governance mechanism that builds on the stability and reputation of existing institutions in the early days but transitions to a fully open system over time.
Are We Decentralized Yet?
- The Official Libra Roadmap White Paper from Members-Only (Permissioned) to Public (Permissionless) Blockchain, PDF Download (~50k, 5 Pages)
We believe that for the Libra network to achieve its full potential, it needs to be permissionless. As a result, one of the association's directives will be to work with the community to research and implement this transition, which will begin within five years of the public launch of the Libra Blockchain and ecosystem.
The (Secure) Contract-Oriented Programming Language for Digital (Blockchain) Resources / Assets
- The Official Move: A Language With Programmable Resources White Paper, PDF Download (~200k, 26 Pages)
Abstract: We present Move, a safe and flexible programming language for the Libra Blockchain. Move is an executable bytecode language used to implement custom transactions and contracts. The key feature of Move is the ability to define custom resource types with semantics inspired by linear logic: a resource can never be copied or implicitly discarded, only moved between program storage locations. These safety guarantees are enforced statically by Move's type system. Despite these special protections, resources are ordinary program values - they can be stored in data structures, passed as arguments to procedures, and so on. First-class resources are a very general concept that programmers can use not only to implement safe digital assets but also to write correct business logic for wrapping assets and enforcing access control policies. The safety and expressivity of Move have enabled us to implement significant parts of the Libra protocol in Move, including Libra coin, transaction processing, and validator management.
Planned to be a statically-typed programming language derived from Rust, compiled to bytecode.
p2p_payment.mvir
- Example of a peer-to-peer transaction script:
// Simple peer-peer payment example.
// Use LibraAccount module published on the blockchain at account address
// 0x0...0 (with 64 zeroes). 0x0 is shorthand that the intermediate representation (IR) pads out to
// 256 bits (64 digits) by adding leading zeroes.
import 0x0.LibraAccount;
import 0x0.LibraCoin;
main(payee: address, amount: u64) {
// The bytecode (and consequently, the intermediate representation (IR)) has typed locals. The scope of
// each local is the entire procedure. All local variable declarations must
// be at the beginning of the procedure. Declaration and initialization of
// variables are separate operations, but the bytecode verifier will prevent
// any attempt to use an uninitialized variable.
let coin: R#LibraCoin.T;
// The R# part of the type above is one of two *kind annotation* R# and V#
// (shorthand for "Resource" and "unrestricted Value"). These annotations
// must match the kind of the type declaration (e.g., does the LibraCoin
// module declare `resource T` or `struct T`?).
// Acquire a LibraCoin.T resource with value `amount` from the sender's
// account. This will fail if the sender's balance is less than `amount`.
coin = LibraAccount.withdraw_from_sender(move(amount));
// Move the LibraCoin.T resource into the account of `payee`. If there is no
// account at the address `payee`, this step will fail
LibraAccount.deposit(move(payee), move(coin));
// Every procedure must end in a `return`. The IR compiler is very literal:
// it directly translates the source it is given. It will not do fancy
// things like inserting missing `return`s.
return;
}
More contract samples (from the Move Contract Playground):
import 0x0.LibraAccount;
import 0x0.LibraCoin;
main(payee: address, amount: u64) {
LibraAccount.mint_to_address(move(payee), move(amount));
return;
}
import 0x0.LibraAccount;
main (payee: address, amount: u64) {
LibraAccount.pay_from_sender(move(payee), move(amount));
return;
}
import 0x0.LibraAccount;
main() {
let addr: address;
let struct1_original_balance: u64;
addr = get_txn_sender();
struct1_original_balance = LibraAccount.balance(copy(addr));
assert(copy(struct1_original_balance) > 10, 77);
return;
}
main() {
let a1: address;
let a2: address;
let a3: address;
let a4: address;
let a5: address;
let a6: address;
let a7: address;
let a8: address;
let a9: address;
a1 = 0x1;
a2 = 0x01;
a3 = 0x0001;
a4 = 0x00000001;
a5 = 0x0000000000000001;
a6 = 0x00000000000000000000000000000001;
a7 = 0x000000000000000000000000000000001;
a8 = 0x000000000000000000000000000000000000000000000000000000000000001;
a9 = 0x0000000000000000000000000000000000000000000000000000000000000001;
assert(copy(a1) == copy(a2), 42);
assert(copy(a2) == copy(a3), 43);
assert(copy(a3) == copy(a4), 44);
assert(copy(a4) == copy(a5), 45);
assert(copy(a5) == copy(a6), 46);
assert(copy(a6) == copy(a7), 47);
assert(copy(a7) == copy(a8), 48);
assert(copy(a8) == copy(a9), 49);
return;
}
import 0x0.LibraAccount;
import 0x0.LibraCoin;
main() {
let addr: address;
let account_exists: bool;
let ten_coins: R#LibraCoin.T;
let account_exists_now: bool;
addr = 0x0111111111111111111111111111111111111011111111111111111111111110;
account_exists = LibraAccount.exists(copy(addr));
assert(!move(account_exists), 83);
ten_coins = LibraAccount.withdraw_from_sender(10);
create_account(copy(addr));
LibraAccount.deposit(copy(addr), move(ten_coins));
account_exists_now = LibraAccount.exists(copy(addr));
assert(move(account_exists_now), 84);
return;
}
Inside Libra Byzantine Fault Tolerance (BFT) and the HotStuff Protocol - The Truth Machine with State Replication
- The Official Libra Byzantine Fault Tolerance (BFT): State Machine Replication in the Blockchain White Paper, PDF Download (~300k, 41 Pages)
Abstract: This report presents LibraBFT, a robust and efficient state machine replication system designed for the Libra Blockchain. LibraBFT is based on HotStuff, a recent protocol that leverages several decades of scientific advances in Byzantine fault tolerance (BFT) and achieves the strong scalability and security properties required by internet settings. LibraBFT further refines the HotStuff protocol to introduce explicit liveness mechanisms and provides a concrete latency analysis. To drive the integration with the Libra Blockchain, this document provides specifications extracted from a fully-functional simulator. These specifications include state replication interfaces and a communication framework for data transfer and state synchronization among participants. Finally, this report provides a formal safety proof that induces criteria to detect misbehavior of BFT nodes, coupled with a simple reward and punishment mechanism.
- What is HotStuff and why is it a big deal by Cypherium, June 18, 2019
- What is the difference between Practical Byzantine Fault Tolerance (PBFT), Tendermint, Scalable Byzantine Fault Tolerance (SBFT) and HotStuff? by Ittai Abraham, June 23, 2019
- Facebook’s proposed currency is technically sound, but should you trust it? by Dapper Labs, June 21, 2019
HotStuff
- HotStuff: Three-chain Rules! by Dahlia Malkhi, October 24, 2018 - Most protocols contain quadratic voting steps. When Byzantine consensus protocols were originally conceived, a typical target system size was n=4 or n=7, tolerating one or two faults. But scaling Byzantine Fault Tolerance (BFT) consensus to n=2000 means that even on a good day, when communication is timely and a handful of failures occurs, quadratic steps require 4,000,000 messages. A cascade of failures might bring the communication complexity to whopping 8,000,000,000 (!) transmissions for a single consensus decision...
- HotStuff: Byzantine Fault Tolerance (BFT) Consensus with Linearity and Responsiveness Whitepaper, PDF Download (~800k, 10 Pages) by Maofan Yin, Dahlia Malkhi, Michael K. Reiter, Guy Golan Gueta, Ittai Abraham - a leader-based Byzantine fault-tolerant replication protocol for the partially synchronous model. Once network communication becomes synchronous, HotStuff enables a correct leader to drive the protocol to consensus at the pace of actual (vs. maximum) network delay - a property called responsiveness - and with communication complexity that is linear in the number of replicas. To our knowledge, HotStuff is the first partially synchronous BFT replication protocol exhibiting these combined properties. Its simplicity enables it to be further pipelined and simplified into a practical, concise protocol for building large-scale replication services.
- Libra Discussion Forum
community.libra.org
- Libra Dev / Tech Updates
@libradev
- Libra Dev / Tech Blog
developers.libra.org/blog
Transactions, Transactions, Transactions
- iLibraExplorer
- Libra Testnet Explorer, (Source) by Gal Diskin - incl. faucet to mint your own free (test) libra tokens / money
- Libra Vista (Testnet Explorer)
- Libranaut (Testnet Explorer)
- Libratics (Testnet Explorer)
Articles & Live Demos
- The First Libra Wallet Proof-of-Concept (POC) - Building your own Wallet and APIs by Nattapon Nimakul, June 23, 2019
JavaScript
- Libra Core by Perfect Makanju - a javascript library client that can be used to interact with libra nodes. Coded in typescript
- Libra gRPC by Fabien - a lightweight JavaScript library for Libra
- Libra API by Fabien - a REST API for Libra blockchain
- Libra Web by Paul C. (Band Protocol) - a javascript client for Libra blockchain. The library allows javascript program to interact with Libra nodes with protobuf message through grpc web. It works in both browser and node.js environments
Python
- PyLibra by Sorawit Suriyakarn (Band Protocol) - a python client for Libra blockchain. The library allows Python program to interact with Libra nodes with protobuf message through grpc
- Libra gRPC by Yehor Smoliakov - a gRPC client for Libra in Python
Go
- Libra Go Client by Ibraheem Bello - a go client for interacting with Libra blockchain
- Libra Go SDK by Philipp Gillé - a go dev kit for Libra
- Libra Example by Philip Kannegaard Hayes - example Libra Go client
Java Libraries
- Libraj by Wen Shen Jun - a java library client that can be used to interact with libra nodes
- Jlibra by Sauli Ketola - a Java library for interacting with the Libra blockchain.
- #libra Topic @ GitHub
- Help & Discussion in Testnet Channel / Category @ Libra Discussion Forum
- Connecting to Libra TestNet on Windows with the Windows Subsystem for Linux (WSL) by Ibraheem Kolawole Bello, June 19th, 2019
- June 18th, 2019 - Libra Testnet Live and Open Source Libra Client (Core) Code
Q: Why is it called Libra? A: The Libra name was inspired by (1) Libra the Roman unit of weight measure, which was eventually used to mint coins. (2) Libra the astrological symbol is the balance of justice, and (3) Libra phonetically sounds like libre, which is French for free or freedom. The Libra name is a combination of money, justice, and freedom.
Did you know? David Marcus is the public face of Facebook's Libra - but Morgan Beller started the cryptocurrency effort in 2017, before Marcus was even at Facebook. (Source: Meet Morgan Beller, the 26-year-old woman behind Facebook's plan to make its own currency, by Salvador Rodriguez (CNBC), July 20, 2019)
Official
- Libra Testimony @ US Senate, Committee on Banking, PDF Download (~100k, 7 Pages) by David Marcus (Libra / Calibra Project Chief / Head), July 16, 2019
- Libra, 2 weeks in by David Marcus (Libra / Calibra Project Chief / Head), July 3, 2019
- Libra: The Path Forward by Libra Engineering Team, June 18, 2019 - Today we are announcing the Libra testnet, a live demonstration of an early prototype of the technology behind Libra - a simple global currency and financial infrastructure that can empower billions of people...
- Coming in 2020: Calibra - A New Digital Wallet for a New Digital Currency by Facebook Newsroom, June 18, 2019
Neutral
- First Look: Libra by Binance Research, June 18th 2019 - An in-depth review of Facebook's long-anticipated entry into cryptocurrency
Regulation, Regulation, Regulation
- Uncle Sam weighs Libra by Ben Munster (Decrypt), July 16, 2019 - Facebook's David Marcus spoke before [the US] Congress on the company's upcoming pseudo-bank, Libra. The oldies on Capitol Hill [in Washington] could barely conceal their contempt...
- [US] Fed[eral] [Reserve] chief [Jerome Powell] calls for Facebook to halt Libra project until concerns addressed, July 10, 2019, Reuters
Scams, Scams, Scams - The Art of the Steal
- Facebook's Libra currency spawns a wave of fakes, including on Facebook itself by Drew Harwell, Tony Romm and Cat Zakrzewski (Washington Post), July 22, 2019 - Roughly a dozen fake accounts, pages and groups scattered across Facebook and its photo-sharing app Instagram present themselves as official hubs for the digital currency, in some cases offering to sell Libra at a discount if viewers visit potentially fraudulent, third-party websites...
Skeptic / Critical Thinking
-
Thoughts on Facebook's Libra Coin by Preston Byrne, July 17, 2019 - Permissioned blockchains: where it all began...
-
Why Facebook's Libra currency gets the thumbs down by Joseph Stiglitz, July 2, 2019 - Facebook has earned a level of distrust that took the banking sector much longer to achieve. Time and again, Facebook's leaders, faced with a choice between money and honouring their promises, have grabbed the money. And nothing could be more about money than creating a new currency. Only a fool would trust Facebook with his or her financial wellbeing. But maybe that's the point: with so much personal data on some 2.4bn monthly active users, who knows better than Facebook just how many suckers are born every minute?
-
The Real Threat From Facebook's Libra Coin by Frances Coppola, June 30, 2019 - Facebook's Libra cryptocurrency is generating an immense amount of hype. Some hail it as the beginning of the end of sovereign currencies. Others believe it will draw people into the cryptocurrency world, leading them inexorably to place their faith in the One True Cryptocurrency, Bitcoin...
-
Facebook's New Currency Has Big Claims and Bad Ideas - Libra is an ideological project, not a practical one by David Gerard (Foreign Policy), June 24, 2019 - Libra has certainly demonstrated one of the main characteristics of blockchain projects - grandiose claims and egregious nonsense...
-
Facebook's Libra Must Be Stopped by Katharian Pistor (Project Syndicate), June 20, 2019 - Facebook has now unveiled a cryptocurrency and payment system that could take down the entire global economy. Governments must intervene before a company that "moves fast and breaks things" ends up breaking everything...
-
Facebook's Cryptocurrency: Stop It Before It Starts by Nicholas Weaver, June 19, 2019 - The [Libra] coin is really a Facebook project. It is not live yet, giving governments the opportunity to kill this project before it gets off the ground and gives rise to cybercriminals who couldn't capitalize on existing cryptocurrencies. In particular, the [Internal Revenue Service] IRS and [the U.S. Treasury's Financial Crimes and Enforcement Network] FinCEN should take action now...
-
FacebookCoin is being announced on Tuesday - and we still don't know why it's a crypto by David Gerard, June 15, 2019 - FacebookCoin is being announced on Tuesday! It's called Libra, and Facebook are apparently stressing very hard that everyone should call it Libra, and not Facebook-anything. And definitely not ZuckerBucks...
- Warum die Politik wegen Facebooks Libra-Coin besorgt ist – und was sie daran nicht versteht by Christoph Bergmann (BitcoinBlog.de) , June 25, 2019
- Facebooks Zuckerbucks: Es hätte schlimmer kommen können by Christoph Bergmann (BitcoinBlog.de), June 18, 2019
- Facebooks GlobalCoin: Gedeckt durch einem Korb anderer Währungen by Christoph Bergmann (BitcoinBlog.de), June 12, 2019
A curated list of awesome lists
- Awesome Libra Blockchain by Copperbits
- Awesome Libra by LearnDapp
- Awesome Libra by Methuz Kaewsaikao
- #awesome-libra Topic @ GitHub
License
The list is dedicated to the public domain. Use it as you please with no restrictions whatsoever.