Home :: Magical Bitcoin

XCP Counterparty Protocol

Counterparty is a protocol for the creation and use of decentralised financial instruments using Bitcoin as a transport layer. It has an open-source and Public Domain reference implementation, counterpartyd, which is available for download/perusal at https://github.com/PhantomPhreak/counterpartyd/.
[link]

true bitcoin must be for the people; needs both decentralization and and access points for layer 2

Bitcoin is fundamentally a protocol so developers who work on it should be focused on making it more robust, easier to use, more efficient, faster, more secure, more private, and providing a wonderful API. The implementation of the bitcoin reference must separate itself from the protocol development. This will solve many of the conflict of interest issues that plague it now.
[link]

An Open Standard To Problem Solving

silene is a community for posting interesting solutions to problems by outlining the solutions themselves and their applications to other problems in a simple, concise manner.
[link]

Should the bitcoin reference implementation consider lowering the min-relay fee to 0.500 SAT/vbyte?

With the mempool emptying daily, there is plenty of opportunity for TXNs below 1.000 SAT/vbyte to clear. Unfortunately, although it is configurable, most nodes take the default config as gospel so low fee TXNs don't propagate through the network to the miners.
Why not have allow lower fee TXNs into the mempool, or make the floor more dynamic like:
if(mempool.size < _10_MB) { min_relay_tx_fee = min_relay_tx_fee >> 1; }
Just seems like eventually, if the market price keeps rising, that it might make since to lower the floor to give miners more TXNs to choose from. I'm sure a miner would prefer a low-fee pool to an empty one.
submitted by brianddk to Bitcoin [link] [comments]

Should the bitcoin reference implementation consider lowering the min-relay fee to 0.500 SAT/vbyte? (x-post from /r/Bitcoin)

submitted by ASICmachine to CryptoCurrencyClassic [link] [comments]

Science: Power Causes Brain Damage [Or, Bitcoin's Reference Implementation Should Be Under the Control of a Much Larger Number of Individuals Than It Is Now.]

Science: Power Causes Brain Damage [Or, Bitcoin's Reference Implementation Should Be Under the Control of a Much Larger Number of Individuals Than It Is Now.] submitted by pecuniology to btc [link] [comments]

Science: Power Causes Brain Damage [Or, Bitcoin's Reference Implementation Should Be Under the Control of a Much Larger Number of Individuals Than It Is Now.]

Science: Power Causes Brain Damage [Or, Bitcoin's Reference Implementation Should Be Under the Control of a Much Larger Number of Individuals Than It Is Now.] submitted by BitcoinAllBot to BitcoinAll [link] [comments]

Node operators, please set the minrelaytxfee to zero as suggested in the docs.

The previous default was 5000 sat/vkB and it was lowered to 1000 sat/vkB on Oct 13, 2015. On that day bitcoin was trading for $255 / BTC. So it was deemed that a relay limit of $0.01275/vkB was too high so it was lowered to $0.00255/vkB. In today's ($11870) figures that would translate to a minrelaytxfee of 0.00000022 sat/vkB.
Since to 0.14.0 release, the minrelaytxfee still defaults to 1000 sat/vkB, but it is recommend in the relnotes that this limit be completely unset.
Since the changes in 0.12 to automatically limit the size of the mempool and improve the performance of block creation in mining code it has not been important for relay nodes or miners to set -minrelaytxfee.
The -minrelaytxfee option continues to exist but is recommended to be left unset.
source: 0.14.0 relnotes
Unsetting this option (-minrelaytxfee=0) will allow lower fee TXNs to make it to the miners. Miners will then have a larger selection of TXNs to choose from. For users concerned about mempool bloat, just set maxmempool below it's default of 300 MB (-maxmempool=200). Or you could set minrelaytxfee to 11 sat/vkB (-minrelaytxfee=0.00000011)
Ultimately, I would think that changing the default in bitcoin-core from 1000 sat/vkB to 100 sat/vkB might be a good move. The mempool has already run dry 6 days this month. No reason not to let the miners continue to mine some super low-fee TXNs if they want to. They control this with blockmintxfee
What I would suggest adding to bitcoin.conf
minrelaytxfee=0 blockmintxfee=0 maxmempool=300
For those wanting to be more conservative:
minrelaytxfee=0.00000011 blockmintxfee=0.00000011 maxmempool=200
Really anything below 1000 sat/vkB would be better.
References:
Thoughts?
submitted by brianddk to Bitcoin [link] [comments]

Bitcoin Cash has no "reference implementation"

Bitcoin Cash has no submitted by georgedonnelly to btc [link] [comments]

Bitcoin Cash has no "reference implementation"

Bitcoin Cash has no submitted by georgedonnelly to Bitcoincash [link] [comments]

Bxc coin

Bitcoin Classic was one of several forks of the Bitcoin reference implementation Bitcoin Core aiming to increase the transaction processing capacity of Bitcoin by increasing the block size limit.[1] Blocks, which contain transaction data, form the basic structure of the immutable blockchain. Bitcoin Classic started out as similar to, though less aggressive than, the Bitcoin XT fork, which never managed to get the support it needed. Bitcoin Classic in its first 8 months promoted a single increase of the maximum block size. I am so much interested to this coin..
submitted by Aware-Opinion to FRIEND [link] [comments]

The reference implementation of Bitcoin adjusts the difficulty level every 2016 blocks. Clearly drift concerns is a recent manifestation.

Satoshi had no intention of making the rate of block discovery accurate and you need look no further than the original DAA that adjusts on a 2016 block interval. It was simply designed to govern the rate of reward and limit the term any one miner gets to control the blockchain.
The blockchain is motivated by work based on random draws, where the only throttle is setting the difficulty bar at a level where the blocks are emitted at a statistically predictable target of 10 minutes. The difficulty for the next 2016 blocks is based on the prior 2016 blocks.
A system design based on a statistically governed random draw, where the throttle adjusts every 2 weeks, shows absolutely no needs or concerns for the concept of drift.
Drift correction is trivia at best, or simply the commonplace pitfalls of bikeshedding and perfection paralysis that creep into any engineering project.
submitted by bitmeister to btc [link] [comments]

Here Is All of the Reference Material Michael Saylor of MicroStrategy Used When The Company Moved to Implement Bitcoin as a Treasury Asset Vehicle

Here Is All of the Reference Material Michael Saylor of MicroStrategy Used When The Company Moved to Implement Bitcoin as a Treasury Asset Vehicle submitted by FellatioFellas to CryptoCurrency [link] [comments]

Here Is All of the Reference Material Michael Saylor of MicroStrategy Used When The Company Moved to Implement Bitcoin as a Treasury Asset Vehicle (x-post from /r/Cryptocurrency)

Here Is All of the Reference Material Michael Saylor of MicroStrategy Used When The Company Moved to Implement Bitcoin as a Treasury Asset Vehicle (x-post from /Cryptocurrency) submitted by ASICmachine to CryptoCurrencyClassic [link] [comments]

Bitcoin Cash Developers Fork ABC Reference Implementation Client, Create "BCH Node"

Bitcoin Cash Developers Fork ABC Reference Implementation Client, Create submitted by afriendofsatoshi to btc [link] [comments]

08-03 22:07 - 'You're confused. I'm not calling BTC "Bitcoin Core", but Wuille [is] a Bitcoin Core developer: / [quote] Bitcoin Core on [wikipedia]: > Bitcoin Core is free and open-source software that serves as a bitcoin node (th...' by /u/MrNotSoRight removed from /r/belgium within 1761-1771min

'''
You're confused. I'm not calling BTC "Bitcoin Core", but Wuille [is]1 a Bitcoin Core developer:
Peter Wuille is a Bitcoin Core developer and the co-founder of Blockstream. He is #2 in terms of commits to Bitcoin Core and is responsible for important improvements to Bitcoin like BIP 66, libsecp256k1, and Segregated Witness.
Bitcoin Core on [wikipedia]2 :
Bitcoin Core is free and open-source software that serves as a bitcoin node (the set of which form the bitcoin network) and provides a bitcoin wallet which fully verifies payments. It is considered to be bitcoin's reference implementation and is the most used implementation by a large margin.
'''
Context Link
Go1dfish undelete link
unreddit undelete link
Author: MrNotSoRight
1: **w.weuseco*ns.com/pie*er**u*lle* 2: en*wikiped*a.or*/wiki/Bi*c**n_*o*e
Unknown links are censored to prevent spreading illicit content.
submitted by removalbot to removalbot [link] [comments]

Why Turing-complete smart contracts are doomed: "Kurt Gödel and Alan Turing both posed the same question: 'Can we find a universal procedure to prove that a mathematical theory is true or false?' They each, in their own way, answered 'NO': there exist some mathematical truths that cannot be proven."

Summary:
(1) Turing-complete languages are fundamentally inappropriate for writing "smart contracts" - because such languages are inherently undecidable, which makes it impossible to know what a "smart contract" will do before running it.
(2) We should learn from Wall Street's existing DSLs (domain-specific languages) for financial products and smart contracts, based on declarative and functional languages such as Ocaml and Haskell - instead of doing what the Web 2.0 "brogrammers" behind Solidity did, and what Peter Todd is also apparently embarking upon: ie, ignoring the lessons that Wall Street has already learned, and "reinventing the wheel", using less-suitable languages such as C++ and JavaScript-like languages (Solidity), simply because they seem "easier" for the "masses" to use.
(3) We should also consider using specification languages (to say what a contract does) along with implementation languages (saying how it should do it) - because specifications are higher-level and easier for people to read than implementations which are lower-level meant for machines to run - and also because ecosystems of specification/implementation language pairs (such as Coq/Ocaml) support formal reasoning and verification tools which could be used to mathematically prove that a smart contract's implementation is "correct" (ie, it satisfies its specification) before even running it.
Details:
http://www.otherpress.com/features/alan-turing-kurt-godel-two-asymptotic-destinies/
https://duckduckgo.com/?q=turing+g%C3%B6del+undecidability&ia=web
https://duckduckgo.com/?q=turing+g%C3%B6del+incompleteness&ia=web
https://duckduckgo.com/?q=%22turing+complete%22+%22g%C3%B6del+incompleteness%22&ia=web
When I have more time later, I will hopefully be able to write up a more gentle introduction on all this stuff, providing more explanations, motivations, and examples for laypersons who are interested in getting a feel for the deep subtle mathematical implications at play here in these emerging "language design wars" around recent proposals to add "smart contracts" to cryptocurrencies.
Right now I'm just providing this quick heads-up / reminder / warning, alluded to in the title of the OP, with some more pointers to the literature in the links above.
People who already do have a deep understanding of mathematics and its history will get the message right away - by recalling the crisis in the foundations of mathematics which occurred in the early 1900s, involving concepts like Russell's paradox, Gödel's incompleteness theorem, undecidability, Turing completeness, etc.
Turing-complete languages lead to "undecidable" programs (ie, you cannot figure out what you do until after you run them)
One hint: recall that Gödel's incompleteness theorem proved that any mathematical system which is (Turing)-complete, must also be inconsistent incomplete [hat tip] - that is, in any such system, it must be possible to formulate propositions which are undecidable within that system.
This is related to things like the Halting Problem.
And by the way, Ethereum's concept of "gas" is not a real solution to the Halting Problem: Yes, running out of "gas" means that the machine will "stop" eventually, but this naïve approach does not overcome the more fundamental problems regarding undecidability of programs written using a Turing-complete language.
The take-away is that:
When using any Turing-complete language, it will always be possible for someone (eg, the DAO hacker, or some crook like Bernie Madoff, or some well-meaning but clueless dev from slock.it) to formulate a "smart contract" whose meaning cannot be determined in advance by merely inspecting the code: ie, it will always be possible to write a smart contract whose meaning can only be determined after running the code.
Take a moment to contemplate the full, deep (and horrifying) implications of all this.
Some of the greatest mathematicians and computer scientists of the 20th century already discovered and definitively proved (much to the consternation most of their less-sophisticated (naïve) colleagues - who nevertheless eventually were forced to come around and begrudgingly agree with them) that:
The horrifying conclusion is that:
This all is based on a very, very deep result of mathematics (Gödel's Incompleteness Theorem, as referenced in some of the links above) - which even many mathematicians themselves had a hard time understanding and accepting.
And it is also very, very common for programmers to not understand or accept this deep mathematical result.
Most programmers do not understand the implications of Gödel's incompleteness theorem on Turing-complete languages
As a mathematician first, and a programmer second, I can confirm from my own experience that most programmers do not understand this important mathematical history at all, and its implications - it is simply too subtle or too foreign for them to grasp.
Their understanding of computing is childish, naïve, and simplistic.
They simply view a computer as a marvelous machine which can execute a sequence of instructions in some language (and please note that, for them, that language usually happens to simply "come with" the machine, so they unquestionably accept whatever language that happens to be - ie, they almost never dive deeper into the subtle concepts of "language design" itself - a specialized area of theoretical computer science which few of them ever think about).
Paradigms lost
As we've seen, time after time, this failure of most programmers contemplate the deeper implications of "language design" has has led to the familiar litany of disasters and "learning experiences" where programmers have slowly abandoned one "programming paradigm" and moved on to the next, after learning (through bitter experience) certain hard facts and unpleasant, non-intuitive realities which initially escaped their attention when they were simply enjoying the naïve thrill of programming - such as the following:
Today, in cryptocurrencies, we are seeing this sad history repeat itself, with plenty of examples of programmers who don't understand these subtle concepts involving the foundations of mathematics - specifically, the mathematical fact (Gödel's Incompleteness Theorem) that any logical system or language which is "powerful" enough to be "Turing complete" must also be inconsistent.
The naïve Ethereum people think they've cleverly sidestepped this with the notion of "gas" but actually all they're doing is cheating with this messy kludge: because simply saying "we'll arbitrarily make the program stop running at some point" does not make "smart contracts" written in Ethereum "decidable" - as we've seen, these contracts can still blow up / go wrong in other ways before they run out of gas.
Peter Todd petertodd might also be an example of this confusion (given his history, my hunch is that he probably is - but I haven't had time to do a thorough investigation yet) - with his recent post proposing smart contracts in Bitcoin based on the lambda calculus.
Basically, the only way to avoid falling into the "Turing tar-pit" of confusing and misleading semantics / behavior and undecidability will be to use slightly more restricted languages which are carefully designed / selected to not be Turing-complete.
There are plenty of non-Turing-complete lanaguages available to learn from.
One possibility would be to consider languages which are based on intuitionistic logic / constructivism / Martin-Löf's Type theory / Heyting Logic - which is similar to classical Boolean logic except that Heyting Logic rejects the Law of the Excluded Middle.
What all these "schools of mathematics" have in common is a more restricted and more concrete notion of "proof", supporting a safer mode of computation, where something is considered "proven" or "true" only if you can provide concrete evidence.
By the way, the word "witness" in "Segregated Witness" - meaning a proof that has been constructed, to "witness" the truth of a proposition, or the validity of a block - comes from the realm of constructivism in mathematics.
These languages are somewhat more restricted than Turing-complete languages, but they are still quite expressive and efficient enough to specify nearly any sort of financial rules or "smart contracts" which we might desire.
In fact, the notion "smart contracts" is actually not new at all, and a lot of related work has already been done in this area - and, interestingly, it is based mostly on the kinds of "functional languages" which most of the developers at Core/Blockstream, and at slock.it, are not familiar with (since they are trapped in the imperative paradigm of less-safe procedural languages such as C++ and JavaScript):
Wall Street is already writing DSLs for "smart contracts" - mostly using functional languages
Check out the many, many languages for smart contracts already being used major financial firms, and notice how most of them are functional (based on Ocaml and Haskell), and not procedural (like C++ and JavaScript):
http://dslfin.org/resources.html
https://stackoverflow.com/questions/23448/dsl-in-finance
The lesson to learn here is simple: Just because we are storing our data on a blockchain and running our code on a permissionless distributed network, does not mean that we should ignore the rich, successful history of existing related work on designing financial products and "smart contracts" which has already been happening on Wall Street using functional languages.
In fact, if we want to run "smart contracts" on a permissionless distributed concurrent parallel network (rather than on a centralized system), then it actually becomes even more important to use functional and declarative paradigms and immutable data structures supported by languages like Ocaml and Haskell, and avoid the imperative and procedural paradigms involving mutable data structures, which are almost impossible to get right in a distributed concurrent parallel architecture. (See the video "The Future is Parallel, and the Future of Parallel is Declarative" for an excellent 1-hour explanation of this).
Only non-Turing-complete languages support formal reasoning and verification
Basically, a language which is not Turing complete, but is instead based on the slightly more restricted "Intuitionistic Logic" or "Constructivism", satisfies an important property where it is possible to do "formal reasoning and verification" about any program written in that language.
This is what we need when dealing with financial products and smart contracts: we need to be able to know in advance "what" the program does (ie, before running it) - which can be done using tools such as formal reasoning and verification and "correctness proofs" (which are not applicable to Turing-complete languages).
Turing-complete languages for "smart contracts" are needlessly dangerous because you can't figure out in advance what they do
As the "language design wars" around cryptocurrencies and "smart contracts" begin to heat up, we must always insist on using only non-Turing-complete languages which enable us to use the tools of formal reasoning and verification to mathematically prove in advance that a "smart contract" program actually does "what" it is supposed to do.
Separating specification from implementation is essential for proving correctness
A specification stating "what the smart contract does" should ideally be spelled out separately from the implementation stating "how" it should do it.
In other words, a high-level, more compact & human-readable specification language can be used to mathematically (and in many cases (semi-)automatically) derive (and formally verify - ie, provide a mathematical correctness proof for) the low-level, hard-to-read machine-runnable program in an implementation language, which tell them machine "how the smart contract does what it does".
A simple list of "language design" requirements for smart contracts
The following considerations are important for ensuring safety of smart contracts:
So, the requirements for languages for smart contracts should include:
(1) Our language should be non-Turing complete - ie, it should be based instead on "Intuititionistic Logic" / "Constructivism";
(2) We should favor declarative languages (and also things like immutable data structures) - because these are the easiest to run on parallel architectures.
(3) Our toolbox should support formal reasoning and verification, allowing us to mathematically prove that a low-level machine-runnable implementation satisfies its high-level, human-readable specification before we actually run it
Some YouTube videos for further study
There's a video discussing how declarative languages with immutable data structures (such as Haskell, which is pure functional) are a nice "fit" for parallel programming:
The Future is Parallel, and the Future of Parallel is Declarative
https://www.youtube.com/watch?v=hlyQjK1qjw8
There's also some videos about how Jane Street Capital has been successfully using the language OCaml (which includes functional, object-oriented, and imperative paradigms) to develop financial products:
Why OCaml
https://www.youtube.com/watch?v=v1CmGbOGb2I
Caml Trading
https://www.youtube.com/watch?v=hKcOkWzj0_s
Lessons from history
When I see Peter Todd writing a blog post where he embarks on informally specifying a new language for "smart contracts for Bitcoin" based on lambda calculus, it makes me shudder and recollect Greenspun's Tenth Rule, which states:
Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.
Only now, it looks like Peter Todd is going to try to single-handedly re-implement languages like Ocaml and Haskell, and then try to build the same financial DSLs (domain-specific languages) which Wall Street already built on them.
I think a much better approach would be to look show a bit more humility, and a little less of the "NIH" (not invented here) syndrome, and see what we can learn from the vast amount of existing work in this area - specifically, the DSLs (domain-specific languages) which Wall Street is already using with great success for automating financial products and smart contracts:
http://dslfin.org/resources.html
https://stackoverflow.com/questions/23448/dsl-in-finance
And remember, most of that existing work involving DSLs for financial products and smart contracts was done on top of functional languages like Ocaml and Haskell - it was not done on top of imperative languages like C++ and JavaScript (and Solidity, which is "JavaScript-like" in many ways).
There are reasons for this - and any so-called dev who ignores that vast body of existing, related work is simply a victim of too much ego and too little awareness of the fin-tech giants who have gone before him.
I'm sure Peter Todd is having a wonderful time being geek with all this - and the hordes of suck-ups and wanna-be's who slavishly worship the C++ pinheads at Core/Blockstream will be duly impressed by all his pseudo-mathematical mumbo-jumbo - but this is mere mental masturbation, if it ignores the major amount of related work that's already been done in this area.
Smart contracts for cryptocurrencies should use Wall Street's existing DSLs financial contracts written in Ocaml and Haskell as a starting point. Eventually maybe we could also even use a language like Coq for writing specifications, and proving that the implementations satisfy the specifications. Any so-called "dev" who fails to acknowledge this previous work is simply not serious.
Ignorance is bliss, and cock-sure Peter Todd is probably merely embarking on a futile mission of hubris by trying to create all this stuff from scratch based on his limited experience as a hacker gamer coder coming from the procedural / imperative paradigm, apparently unaware of the decades of related work which have shown that doing provably correct parallel programming is a gargantuan arduous challenge which may very well turn out to be insurmountable at this time.**
Lord help us if this immature, ignorant vandal who wants Bitcoin to fail takes the ignorant followers of r\bitcoin and Core down the path of these so-called "smart contracts" - reinventing decades of work already done on Wall Street and academia using Haskell and Ocaml, as they screw around with "easier" languages based on C++ and JavaScript.
Further reading
For more discussion about the emerging "language design wars" around the idea of possibly adding "smart contracts" to cryptocurrencies, here are some recent links from Reddit:
The bug which the "DAO hacker" exploited was not "merely in the DAO itself" (ie, separate from Ethereum). The bug was in Ethereum's language design itself (Solidity / EVM - Ethereum Virtual Machine) - shown by the "recursive call bug discovery" divulged (and dismissed) on slock.it last week.
https://np.reddit.com/btc/comments/4op2es/the_bug_which_the_dao_hacker_exploited_was_not/
https://np.reddit.com/ethereum/comments/4opjov/the_bug_which_the_dao_hacker_exploited_was_not/
Can we please never again put 100m in a contract without formal correctness proofs?
https://np.reddit.com/ethereum/comments/4oimok/can_we_please_never_again_put_100m_in_a_contract/
Would the smart formal methods people here mind chiming in with some calm advice on this thread?
https://np.reddit.com/haskell/comments/4ois15/would_the_smart_formal_methods_people_here_mind/
submitted by ydtm to btc [link] [comments]

Bitcoin Cash Reference Implementation Bitcoin ABC Announces Business Plan Fundraising Drive

Bitcoin Cash Reference Implementation Bitcoin ABC Announces Business Plan Fundraising Drive submitted by afriendofsatoshi to btc [link] [comments]

Bitcoin Cash Reference Implementation Bitcoin ABC Announces Business Plan Fundraising Drive

Bitcoin Cash Reference Implementation Bitcoin ABC Announces Business Plan Fundraising Drive submitted by afriendofsatoshi to Bitcoincash [link] [comments]

Our Bitcoin-related dockerfiles and configurations optimized for performace, lightweight (some raspberry pi specific), security by default and scalability are live at www.bitcoindockers.com

This is the public repository of dockerfiles used in production by Satoshi Portal for the Bitcoin applications it develops and operates, including Byllsand Bitcoin Outlet. In other words: they are currently being used to send and receive bitcoins commercially the mainnet.
Announcement : “Dockerizing Bitcoin” @francispouliot_ https://medium.com/satoshiportal/bitcoin-dockers-21f9d5dd1e58
We will regularily update the existing Dockerfiles and add more. We ourselves tried to create the least now code possible, using the best standards and open-source software, and with security-by-default because we are running Bitcoin exchange applications that are an obvious high-value target for attackers.
We hope that by creating docker containers of useful and popular Bitcoin open-source software projects, we will make it easier for developers and project managers to build applications on top of Bitcoin. If you need help or have requests don’t hesitate to reach out using the contribution guidelines below. this
Please submit improvements and post your comments, we definitely want to get better with your help!
This repo is hosted at bitcoindockers.com
Features
Lightweight alpine-based docker containers (runnable on RPi’s and other small devices)
Using less possible new code, most possible existing OS built-in/well-known softwares
Using container OS as running platform instead of language-based interpreter
Encrypting everything through Docker Encrypted Overlay Network
Distributing everything through Docker Swarm to maximize scallability
Exposing nothing outside the overlay network
Our philosophy: Security, Lightweight, Performance & Scalability.
List of Dockerfiles
HD address derivation (segwit, bech32, etc.): a command-line too to derive bitcoin addresses using master public keys. This is useful for generating Bitcoin receiving addresses.
Pycoin: a crypto-utility useful for deriving Bitcoin addresses in Python.
Bitcoin Core x86_64: the Bitcoin reference implementation (full node) of Bitcoin from Bitcoin Core
Bitcoin Core for Raspberry Pi: the Bitcoin reference implementation (full node) of Bitcoin from Bitcoin Core optmized for running on aRaspberry Pi device
C-Lightning: one of the major Lightning Network implementations optmized for running on aRaspberry Pi device
LND Lighnting Network Node one of the major Lightning Network implementations optmized for running on a Raspberry Pi device
OpenTimestamp Server: a network calendar and aggregation utility service for scalable timestamping of hashed data using the Bitcoin blockchain as a notary, from Open Timestamps
OpenTimestamp Client: software to communicate with OTS server and Bitcoin Core to generate and verify timestamps compliant with the Open Timestamps protocol
If you want us to create a docker, please create an issue this way:
Hope you enjoy it!
submitted by FrancisPouliot to docker [link] [comments]

Bitcoin Cash Developers Fork ABC Reference Implementation Client, Create "BCH Node"

Bitcoin Cash Developers Fork ABC Reference Implementation Client, Create submitted by afriendofsatoshi to Bitcoincash [link] [comments]

Why Turing-complete smart contracts are doomed: "Kurt Gödel and Alan Turing both posed the same question: 'Can we find a universal procedure to prove that a mathematical theory is true or false?' They each, in their own way, answered 'NO': there exist some mathematical truths that cannot be proven."

(Cross-post from btc.)
Summary:
(1) Turing-complete languages are fundamentally inappropriate for writing "smart contracts" - because such languages are inherently undecidable, which makes it impossible to know what a "smart contract" will do before running it.
(2) We should learn from Wall Street's existing DSLs (domain-specific languages) for financial products and smart contracts, based on declarative and functional languages such as Ocaml and Haskell - instead of doing what the Web 2.0 "brogrammers" behind Solidity did, and what Peter Todd is also apparently embarking upon: ie, ignoring the lessons that Wall Street has already learned, and "reinventing the wheel", using less-suitable languages such as C++ and JavaScript-like languages (Solidity), simply because they seem "easier" for the "masses" to use.
(3) We should also consider using specification languages (to say what a contract does) along with implementation languages (saying how it should do it) - because specifications are higher-level and easier for people to read than implementations which are lower-level meant for machines to run - and also because ecosystems of specification/implementation language pairs (such as Coq/Ocaml) support formal reasoning and verification tools which could be used to mathematically prove that a smart contract's implementation is "correct" (ie, it satisfies its specification) before even running it.
Details:
http://www.otherpress.com/features/alan-turing-kurt-godel-two-asymptotic-destinies/
https://duckduckgo.com/?q=turing+g%C3%B6del+undecidability&ia=web
https://duckduckgo.com/?q=turing+g%C3%B6del+incompleteness&ia=web
https://duckduckgo.com/?q=%22turing+complete%22+%22g%C3%B6del+incompleteness%22&ia=web
When I have more time later, I will hopefully be able to write up a more gentle introduction on all this stuff, providing more explanations, motivations, and examples for laypersons who are interested in getting a feel for the deep subtle mathematical implications at play here in these emerging "language design wars" around recent proposals to add "smart contracts" to cryptocurrencies.
Right now I'm just providing this quick heads-up / reminder / warning, alluded to in the title of the OP, with some more pointers to the literature in the links above.
People who already do have a deep understanding of mathematics and its history will get the message right away - by recalling the crisis in the foundations of mathematics which occurred in the early 1900s, involving concepts like Russell's paradox, Gödel's incompleteness theorem, undecidability, Turing completeness, etc.
Turing-complete languages lead to "undecidable" programs (ie, you cannot figure out what you do until after you run them)
One hint: recall that Gödel's incompleteness theorem proved that any mathematical system which is (Turing)-complete, must also be inconsistent - that is, in any such system, it must be possible to formulate propositions which are undecidable within that system.
This is related to things like the Halting Problem.
And by the way, Ethereum's concept of "gas" is not a real solution to the Halting Problem: Yes, running out of "gas" means that the machine will "stop" eventually, but this naïve approach does not overcome the more fundamental problems regarding undecidability of programs written using a Turing-complete language.
The take-away is that:
When using any Turing-complete language, it will always be possible for someone (eg, the DAO hacker, or some crook like Bernie Madoff, or some well-meaning but clueless dev from slock.it) to formulate a "smart contract" whose meaning cannot be determined in advance by merely inspecting the code: ie, it will always be possible to write a smart contract whose meaning can only be determined after running the code.
Take a moment to contemplate the full, deep (and horrifying) implications of all this.
Some of the greatest mathematicians and computer scientists of the 20th century already discovered and definitively proved (much to the consternation most of their less-sophisticated (naïve) colleagues - who nevertheless eventually were forced to come around and begrudgingly agree with them) that:
The horrifying conclusion is that:
This all is based on a very, very deep result of mathematics (Gödel's Incompleteness Theorem, as referenced in some of the links above) - which even many mathematicians themselves had a hard time understanding and accepting.
And it is also very, very common for programmers to not understand or accept this deep mathematical result.
Most programmers do not understand the implications of Gödel's incompleteness theorem on Turing-complete languages
As a mathematician first, and a programmer second, I can confirm from my own experience that most programmers do not understand this important mathematical history at all, and its implications - it is simply too subtle or too foreign for them to grasp.
Their understanding of computing is childish, naïve, and simplistic.
They simply view a computer as a marvelous machine which can execute a sequence of instructions in some language (and please note that, for them, that language usually happens to simply "come with" the machine, so they unquestionably accept whatever language that happens to be - ie, they almost never dive deeper into the subtle concepts of "language design" itself - a specialized area of theoretical computer science which few of them ever think about).
Paradigms lost
As we've seen, time after time, this failure of most programmers contemplate the deeper implications of "language design" has has led to the familiar litany of disasters and "learning experiences" where programmers have slowly abandoned one "programming paradigm" and moved on to the next, after learning (through bitter experience) certain hard facts and unpleasant, non-intuitive realities which initially escaped their attention when they were simply enjoying the naïve thrill of programming - such as the following:
Today, in cryptocurrencies, we are seeing this sad history repeat itself, with plenty of examples of programmers who don't understand these subtle concepts involving the foundations of mathematics - specifically, the mathematical fact (Gödel's Incompleteness Theorem) that any logical system or language which is "powerful" enough to be "Turing complete" must also be inconsistent.
The naïve Ethereum people think they've cleverly sidestepped this with the notion of "gas" but actually all they're doing is cheating with this messy kludge: because simply saying "we'll arbitrarily make the program stop running at some point" does not make "smart contracts" written in Ethereum "decidable" - as we've seen, these contracts can still blow up / go wrong in other ways before they run out of gas.
Peter Todd petertodd might also be an example of this confusion (given his history, my hunch is that he probably is - but I haven't had time to do a thorough investigation yet) - with his recent post proposing smart contracts in Bitcoin based on the lambda calculus.
Basically, the only way to avoid falling into the "Turing tar-pit" of confusing and misleading semantics / behavior and undecidability will be to use slightly more restricted languages which are carefully designed / selected to not be Turing-complete.
There are plenty of non-Turing-complete lanaguages available to learn from.
One possibility would be to consider languages which are based on intuitionistic logic / constructivism / Martin-Löf's Type theory / Heyting Logic - which is similar to classical Boolean logic except that Heyting Logic rejects the Law of the Excluded Middle.
What all these "schools of mathematics" have in common is a more restricted and more concrete notion of "proof", supporting a safer mode of computation, where something is considered "proven" or "true" only if you can provide concrete evidence.
By the way, the word "witness" in "Segregated Witness" - meaning a proof that has been constructed, to "witness" the truth of a proposition, or the validity of a block - comes from the realm of constructivism in mathematics.
These languages are somewhat more restricted than Turing-complete languages, but they are still quite expressive and efficient enough to specify nearly any sort of financial rules or "smart contracts" which we might desire.
In fact, the notion "smart contracts" is actually not new at all, and a lot of related work has already been done in this area - and, interestingly, it is based mostly on the kinds of "functional languages" which most of the developers at Core/Blockstream, and at slock.it, are not familiar with (since they are trapped in the imperative paradigm of less-safe procedural languages such as C++ and JavaScript):
Wall Street is already writing DSLs for "smart contracts" - mostly using functional languages
Check out the many, many languages for smart contracts already being used major financial firms, and notice how most of them are functional (based on Ocaml and Haskell), and not procedural (like C++ and JavaScript):
http://dslfin.org/resources.html
https://stackoverflow.com/questions/23448/dsl-in-finance
The lesson to learn here is simple: Just because we are storing our data on a blockchain and running our code on a permissionless distributed network, does not mean that we should ignore the rich, successful history of existing related work on designing financial products and "smart contracts" which has already been happening on Wall Street using functional languages.
In fact, if we want to run "smart contracts" on a permissionless distributed concurrent parallel network (rather than on a centralized system), then it actually becomes even more important to use functional and declarative paradigms and immutable data structures supported by languages like Ocaml and Haskell, and avoid the imperative and procedural paradigms involving mutable data structures, which are almost impossible to get right in a distributed concurrent parallel architecture. (See the video "The Future is Parallel, and the Future of Parallel is Declarative" for an excellent 1-hour explanation of this).
Only non-Turing-complete languages support formal reasoning and verification
Basically, a language which is not Turing complete, but is instead based on the slightly more restricted "Intuitionistic Logic" or "Constructivism", satisfies an important property where it is possible to do "formal reasoning and verification" about any program written in that language.
This is what we need when dealing with financial products and smart contracts: we need to be able to know in advance "what" the program does (ie, before running it) - which can be done using tools such as formal reasoning and verification and "correctness proofs" (which are not applicable to Turing-complete languages).
Turing-complete languages for "smart contracts" are needlessly dangerous because you can't figure out in advance what they do
As the "language design wars" around cryptocurrencies and "smart contracts" begin to heat up, we must always insist on using only non-Turing-complete languages which enable us to use the tools of formal reasoning and verification to mathematically prove in advance that a "smart contract" program actually does "what" it is supposed to do.
Separating specification from implementation is essential for proving correctness
A specification stating "what the smart contract does" should ideally be spelled out separately from the implementation stating "how" it should do it.
In other words, a high-level, more compact & human-readable specification language can be used to mathematically (and in many cases (semi-)automatically) derive (and formally verify - ie, provide a mathematical correctness proof for) the low-level, hard-to-read machine-runnable program in an implementation language, which tell them machine "how the smart contract does what it does".
A simple list of "language design" requirements for smart contracts
The following considerations are important for ensuring safety of smart contracts:
So, the requirements for languages for smart contracts should include:
(1) Our language should be non-Turing complete - ie, it should be based instead on "Intuititionistic Logic" / "Constructivism";
(2) We should favor declarative languages (and also things like immutable data structures) - because these are the easiest to run on parallel architectures.
(3) Our toolbox should support formal reasoning and verification, allowing us to mathematically prove that a low-level machine-runnable implementation satisfies its high-level, human-readable specification before we actually run it
Some YouTube videos for further study
There's a video discussing how declarative languages with immutable data structures (such as Haskell, which is pure functional) are a nice "fit" for parallel programming:
The Future is Parallel, and the Future of Parallel is Declarative
https://www.youtube.com/watch?v=hlyQjK1qjw8
There's also some videos about how Jane Street Capital has been successfully using the language OCaml (which includes functional, object-oriented, and imperative paradigms) to develop financial products:
Why OCaml
https://www.youtube.com/watch?v=v1CmGbOGb2I
Caml Trading
https://www.youtube.com/watch?v=hKcOkWzj0_s
Lessons from history
When I see Peter Todd writing a blog post where he embarks on informally specifying a new language for "smart contracts for Bitcoin" based on lambda calculus, it makes me shudder and recollect Greenspun's Tenth Rule, which states:
Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.
Only now, it looks like Peter Todd is going to try to single-handedly re-implement languages like Ocaml and Haskell, and then try to build the same financial DSLs (domain-specific languages) which Wall Street already built on them.
I think a much better approach would be to look show a bit more humility, and a little less of the "NIH" (not invented here) syndrome, and see what we can learn from the vast amount of existing work in this area - specifically, the DSLs (domain-specific languages) which Wall Street is already using with great success for automating financial products and smart contracts:
http://dslfin.org/resources.html
https://stackoverflow.com/questions/23448/dsl-in-finance
And remember, most of that existing work involving DSLs for financial products and smart contracts was done on top of functional languages like Ocaml and Haskell - it was not done on top of imperative languages like C++ and JavaScript (and Solidity, which is "JavaScript-like" in many ways).
There are reasons for this - and any so-called dev who ignores that vast body of existing, related work is simply a victim of too much ego and too little awareness of the fin-tech giants who have gone before him.
I'm sure Peter Todd is having a wonderful time being geek with all this - and the hordes of suck-ups and wanna-be's who slavishly worship the C++ pinheads at Core/Blockstream will be duly impressed by all his pseudo-mathematical mumbo-jumbo - but this is mere mental masturbation, if it ignores the major amount of related work that's already been done in this area.
Smart contracts for cryptocurrencies should use Wall Street's existing DSLs financial contracts written in Ocaml and Haskell as a starting point. Eventually maybe we could also even use a language like Coq for writing specifications, and proving that the implementations satisfy the specifications. Any so-called "dev" who fails to acknowledge this previous work is simply not serious.
Ignorance is bliss, and cock-sure Peter Todd is probably merely embarking on a futile mission of hubris by trying to create all this stuff from scratch based on his limited experience as a hacker gamer coder coming from the procedural / imperative paradigm, apparently unaware of the decades of related work which have shown that doing provably correct parallel programming is a gargantuan arduous challenge which may very well turn out to be insurmountable at this time.**
Lord help us if this immature, ignorant vandal who wants Bitcoin to fail takes the ignorant followers of r\bitcoin and Core down the path of these so-called "smart contracts" - reinventing decades of work already done on Wall Street and academia using Haskell and Ocaml, as they screw around with "easier" languages based on C++ and JavaScript.
Further reading
For more discussion about the emerging "language design wars" around the idea of possibly adding "smart contracts" to cryptocurrencies, here are some recent links from Reddit:
The bug which the "DAO hacker" exploited was not "merely in the DAO itself" (ie, separate from Ethereum). The bug was in Ethereum's language design itself (Solidity / EVM - Ethereum Virtual Machine) - shown by the "recursive call bug discovery" divulged (and dismissed) on slock.it last week.
https://np.reddit.com/btc/comments/4op2es/the_bug_which_the_dao_hacker_exploited_was_not/
https://np.reddit.com/ethereum/comments/4opjov/the_bug_which_the_dao_hacker_exploited_was_not/
Can we please never again put 100m in a contract without formal correctness proofs?
https://np.reddit.com/ethereum/comments/4oimok/can_we_please_never_again_put_100m_in_a_contract/
Would the smart formal methods people here mind chiming in with some calm advice on this thread?
https://np.reddit.com/haskell/comments/4ois15/would_the_smart_formal_methods_people_here_mind/
submitted by ydtm to ethereum [link] [comments]

BIP66 Resolution Criteria

The canonical Bitcoin Reference Implementation is 0.5.3.
A blockchain that does not validate under 0.5.3 is an altcoin blockchain.
See also: http://therealbitcoin.org/ml/btc-dev/2015-July/thread.html
submitted by nugyar to Bitcoin [link] [comments]

Dr Gavin Wood and company release Parity Bitcoin - a high performance and reliable alternative to existing Bitcoin software written in rust

This is an automatic summary, original reduced by 26%.
Parity Technologies, led by Ethereum co-founder Dr Gavin Wood, has released the Parity Bitcoin technology stack and new implementation of the Bitcoin protocol written in Rust, a high performance and reliable alternative to existing Bitcoin software.
Parity Bitcoin is fully compliant with the legacy Bitcoin reference implementation and built from the ground up to the highest standards of software development, said a statement.
Wood, founder of Parity Technologies, reckons that Rust's clean code, performance and reliability will make Parity Bitcoin the go-to platform for developers.
"We're really glad to hand this to the Bitcoin developer community and hope the fresh start can form a springboard for innovation. We'd love to work with other Bitcoin protocol folk to get key improvements like Schnorr signature schemes widely adopted," he said.
The development was initially sponsored by leading Bitcoin mining pools F2Pool, Bixin and Bitmain, which commented: "Parity's implementation is an excellent addition to a growing number of Bitcoin implementations. The diversity and choice better represent the different participants in the eco-system, allowing everyone to adopt a solution that works for them."
Zooko Wilcox-O'Hearn, founder of Zcash, also commented on the release: "Zcash is based on Bitcoin and we've started using Rust, so we're delighted to see a full Bitcoin implementation in Rust from a good team. This kind of innovation helps move the whole ecosystem forward'" he said.
Summary Source | FAQ | Theory | Feedback | Top five keywords: Bitcoin#1 Parity#2 implementation#3 software#4 Rust#5
Post found in /Bitcoin, /ethtrader, /btc, /ethereum, /ethernews and /BitcoinAll.
NOTICE: This thread is for discussing the submission topic. Please do not discuss the concept of the autotldr bot here.
submitted by autotldr to autotldr [link] [comments]

51% Mining Problem

Why doesn't bitcoin have some type of auto-checkpointing functionality based on difficulty? Am I missing something?
Here's a ridiculous example: Let's say that a government or large attacker has been mining its own fork for the past six months. The whole time their fork's difficulty has been greater than the real blockchain so they're version of events would be the accepted version if they released their fork into the wild. Thousands upon thousands of blocks would be orphaned as the bitcoin reference implementation recognized the attackers blockchain as authoritative.
What's to stop this from happening? In the past checkpoints were put in place in the software.
Why not have the current clients auto-checkpoint based on difficulty? The higher the difficulty rate then the smaller the checkpoint offset would be. So, for example, we had 10,000 blocks that could be orphaned at bitcoin's beginning maybe the maximum today would be a few hundred, or even a few dozen.
Any attacker would need to have quite a bit more than 51% of the hashing power plus a good deal of luck to be able to outpace the checkpoint.
submitted by pgrigor to Bitcoin [link] [comments]

How does a blockchain work - Simply Explained - YouTube CoinSpice Podcast 79 Amaury Séchet BCH May 2020 Upgrade Part 2 Bitcoin Core Server for Windows 2016 Satoshi's Secret Identity Revealed? Bitcoin Fireside Chat with Marc Andreessen and Balaji ...

Although the target threshold should be an unsigned integer, the original nBits implementation inherits properties from a signed data class, allowing the target threshold to be negative if the high bit of the significand is set. This is useless—the header hash is treated as an unsigned number, so it can never be equal to or lower than a negative target threshold. Bitcoin Core deals with this ... Bitcoin Core . The base of a sovereign Bitcoin node is a fully validating Bitcoin client. We are using Bitcoin Core, the reference implementation, but not the only option available. This application will download the whole blockchain from other peers and validate every single transaction that ever happened. After validation, the client can check all future transactions whether they are valid ... Reference implementation. A reference implementation is a function or feature in either hardware or software recommended by someone, that, if implemented, will help in some way. The current specification documents are complex and wide-ranging. So, even making a small implementation is a hard judgement to make just by going off of what is written in a specification document. With specification ... navigation Bitcoin Dev Kit. The Bitcoin Dev Kit (BDK) project (originally called Magical Bitcoin 🧙) aims to build a collection of tools and libraries that are designed to be a solid foundation for cross platform Bitcoin wallets, along with a fully working reference implementation wallet called Magical Bitcoin. All BDK components are designed to be lightweight and modular so that they can be ... Bitcoin implementation in Scala. Get started. Deep protocol understanding. Bitcoin-S allows you to interact with data structures found in the Bitcoin and Lightning protocols as first-class citizens of your app. Go back and forth between hex, byte and JVM representation trivially, letting our abstractions focus on what you want to build . Immutable data structures. Code with confidence, knowing ...

[index] [23699] [46924] [24680] [45103] [24501] [2357] [4254] [42977] [47125] [51261]

How does a blockchain work - Simply Explained - YouTube

TL;DR: Amaury Séchet is back for our second in a series of conversations about the May 15, 2020 scheduled network upgrade for Bitcoin Cash (BCH). He’s lead d... Chaine d'information Sans Limites TV éditée par le Groupe GSL Communication, Ouest Foire Dakar ( Sénégal ) Directeur de Publication : Yankhoba SANE SERVICE C... Keywords/phrases: Will Bitcoin become a state-backed global currency? As a reference of value for national fiat currencies. A mandatory one-world currency is statist monolith that can only be ... Learn more at www.coinsumm.it Fireside chat with Marc Andreessen and Balaji Srinivasan, Andreessen Horowitz Moderated by Kashmir Hill, Forbes Many people have claimed to be Satoshi Nakamoto which is the name used by the pseudonymous person or persons who developed bitcoin, authored the bitcoin whit...

#