2020-01-18T20:08:37Z

Joshua Henslee: /* The Ledger */

[[Special:UserLogin|Temporary log in link]]

Welcome to the BitcoinSV wiki. Here we aim to provide a correct and up-to date set of information on the Bitcoin network and its features and functionality.

===Bitcoin===

'''Bitcoin''' is a peer to peer cash system created by [https://craigwright.net/ Dr. Craig Wright] under the pseudonym [[Satoshi Nakamoto]] and released as open-source software in 2009. It does not rely on a central server to process transactions or store funds. The leaderless structure of the network famously solves [[The Byzantine Generals Problem]] allowing disconnected entities to follow a common direction without centralised instruction.

===The Ledger===
The Bitcoin ledger is also formed as a [[wikipedia:Directed Acyclic Graph|Directed acyclic graph]] (DAG) where each transaction is a node. Following this graph back can trace every the ownership of every coin in an unbroken chain of signatures back to the original [[Coinbase]] transactions.
The ledger is held on a [https://en.wikipedia.org/wiki/Distributed_networking distributed network] of nodes who compete with each other to extend it.

Miners gather transactions from the network and evaluate whether they want to mine them or not.

[[GetBlockTemplate interface|Block templates]] are created by a node which calculates the root of a [https://en.wikipedia.org/wiki/Merkle_tree Merkle tree] containing all of the transactions they are attempting to mine. As new transactions arrive, they are added to the tree.

===Nodes===
Nodes are operated by the [[Mining|Bitcoin mining enterprises]] who build the network. Bitcoin's economic incentives are structured such that for the nodes to be most profitable at building the ledger they must be as closely connected to other well performing nodes as possible. This leads to miners forming a [[Small World Network]] which trends towards a [[Nearly Complete Graph]] where all miners are connected to all other miners. Miners gather transactions from users who connect in a layered network over the nodes at the core forming a [[Mandala Network]]. In this shell network, peers use [[Simplified Payment Verification]] to form a much less densely packed structure where information is exchanged in [[Payment Channels]].

As Bitcoin scales, the nodes who comprise the network will be variously compartmentalised into specialised hardware. These clustered systems will be distributed globally, each being placed in a location optimised for its task.

===Proof of Work===
The miners use hash based [[Proof of Work]] to compete for the right to extend the ledger, and as a means to vote on [[Network|network rules]].

===Unit of account===
[[Satoshis]] are the ledger's native unit of account and 100,000,000 satoshis is abstracted to one Bitcoin. Satoshis are held in script puzzles called [[UTXO|Unspent Transaction Outputs or UTXOs]]. These are [[VOUT|outputs]] from [[Bitcoin Transactions]] which are held by miners in a quick access database called the UTXO set. During the spending process, UTXOs being used in a transaction are consumed and the solution to their puzzle script is recorded in the transaction.

===Subsidy===
Satoshis are issued by miners to themselves as a [[Block subsidy|subsidy payment]] during the network establishment phase. As the network matures, the the subsidy dissipates forcing the miners to find alternate revenue streams. The payment allows miners to finance their operations through the payment of goods and services in Bitcoin, spreading them through the economy.

===Transactions===
All transactions are [[Payments in Bitcoin|payments]]. Transactions are written in a flexible [[Opcodes used in Bitcoin Script|scripting language]] that is used to assign ownership rights to each transaction output.
All network events including the creation of a block are inscribed in transactions.

Valid transactions that are broadcast on [[The Bitcoin Network]] are committed to the Bitcoin public ledger by miners in [[Block|Blocks]]. Blocks are discovered just under every 10 minutes on average and held in a a [[wikipedia:Directed Acyclic Graph|Directed acyclic graph]] (DAG) structured as a [[Block chain]]. Each block forms a node in the graph. This graph is consistent in structure and can be traced back to the [[Genesis block|first block mined]].

Transactions can be exchanged peer to peer, allowing them to be modified in payment channels. Once a transactions is sent to the network in a closed channel, global [[consensus|Consensus]] can be reached on the validity in less than 2 seconds.

===Network rules===
Bitcoin operates on a fixed ruleset. consensus is based on things such as the rate at which new bitcoins are issued, the mathematical rules outlining the target for the [[Difficulty]] algorithm and more. The protocol is agreed upon by the miners who control network operation.

===Limits===
There are no limits in the [[Protocol|Bitcoin protocol]]. Any limits imposed are are put in place by miners who are incentivised to catch the largest profitable pools of transactions they can. Miners compete to offer better service to fee paying users by scaling their own capabilities.

===History===
[[Bitcoin until today|Bitcoin has a rich history]] and has been [[Attacks on Bitcoin|attacked]] in many ways since its inception.

===Tools and Building on Bitcoin===
Bitcoin has a rich and diverse [[Building on Bitcoin|set of tools]] which are being added to all the time.

Double-spending

2020-01-18T20:06:24Z

Joshua Henslee:

===Definition===
Double spending is the act of sending a [[Bitcoin_Transactions|transaction]] containing inputs that have already been spent, in an attempt to commit fraud on the network.

===Consequences===
Double spends are one of the most commonly discussed attacks on Bitcoin however there has yet to be a documented case of someone executing a successful double spend using Bitcoin in commerce.

The reason for this is that double spending is a crime and analogous to intentionally bouncing a check - the difference is that the merchant would have cryptographic proof that the customer attempted such an act.

===Economic incentives===
Bitcoin solves the double spending problem via its economic incentives. Miners have a strong incentive not to include these transactions in a block because they are at risk of having their block rejected by other miners as well as would be complicit in carrying out a crime.

These factors highlight why the solution to double spending is an economic solution, not a technical one. Many arguments have been made by developers in the past that changes are necessary to the protocol to fix this issue, but they are all unnecessary.

Double-spending

2020-01-18T20:06:03Z

Joshua Henslee: /* Definition */

Double-spending

2020-01-18T20:03:27Z

Joshua Henslee:

===Definition===
Double spending is the act of sending a transaction containing inputs that have already been spent, in an attempt to commit fraud on the network.

===Consequences===
Double spends are one of the most commonly discussed attacks on Bitcoin however there has yet to be a documented case of someone executing a successful double spend using Bitcoin in commerce.

The reason for this is that double spending is a crime and analogous to intentionally bouncing a check - the difference is that the merchant would have cryptographic proof that the customer attempted such an act.

===Economic incentives===
Bitcoin solves the double spending problem via its economic incentives. Miners have a strong incentive not to include these transactions in a block because they are at risk of having their block rejected by other miners as well as would be complicit in carrying out a crime.

These factors highlight why the solution to double spending is an economic solution, not a technical one. Many arguments have been made by developers in the past that changes are necessary to the protocol to fix this issue, but they are all unnecessary.

[[Bitcoin Transactions]] are typically [[Irreversible Transactions|irreversible]] once they have been broadcast to the mining network.

Paper wallet

2020-01-18T19:52:14Z

Joshua Henslee: /* Redeeming bitcoins and withdrawing funds */

A '''paper wallet''' is the name given to a method of storing bitcoin which involves printing a single [[Private Keys|private key]] and bitcoin [[address]] onto paper and depositing funds into a [[Bitcoin Transactions#P2PHK|P2PKH]] script using the address. Funds can be accessed by accessing the physical paper and entering the private key into a wallet. This is usually achieved by scanning a QR code of the private key in [[Wallet import format]].

== Redeeming bitcoins and withdrawing funds ==

The best way to redeem the bitcoins from a private key is to use the "sweep" feature of certain wallet software. This sends the entire balance of the paper wallet to a [[deterministic wallet]]. Alternatively the private key could be imported and the entire balance sent to an address in the wallet.

There are various wallets for doing this:

* [https://electrumsv.io/ ElectrumSV] and [https://simply.cash/ Simply Cash] support sweeping private keys.

==Downsides/Risks==

Paper wallets are seen as a secure method of long term storage of funds however there are downsides to using this method.

===Printing===

Paper wallets require using a printer to transfer them to paper. Most printers have internal storage where the image of the wallet could be saved allowing an attacker with access to the printer to see the private key and steal the stored bitcoins. Shared printers such as in schools, offices or internet cafes are also usually centrally logged. If the printer is accessed over WiFi then any radio wave listener could also obtain the private keys and steal the money.

[[Seed phrase]]s avoid this problem by having the user transfer the sensitive information to paper without a printer but via their own handwriting.

=== Address reuse ===

Paper wallets have just one bitcoin address, leading to [[address reuse]].

=== Poor user experience ===

Dealing with raw private keys can be unintuitive and may lead to loss of funds if not managed properly. It is recommended that users of paper wallets understand how they function before using them as long term funds storage.

=== Low error correction ===

The private keys are typically printed in small fonts. Sometimes characters may be mistaken for another letter. One single wrong character will invalidate the key. Private keys in WIF format have a checksum but there are a lack of tools for regular users to correct mistakes.

While QR codes have a checksum and robust error correction, they can be damaged by water, crumpling or folding of the paper.

=== Paper wallet software ===

Many paper wallets are created with website using Javascript cryptography, which is considered unsafe for anything related to bitcoin.

== Bitcoin ATMs and paper wallets ==

Many bitcoin ATMs use a paper-wallet-like system for delivering bitcoins if the customer doesn't have a bitcoin wallet. The ATMs can print out a private key/address pair onto paper which contain the customer's bitcoins. Ideally the customer would sweep the bitcoins into their own wallet as soon as they can.

== See Also ==

* [[Private Keys]]
* [[Seed phrase]]

Seed phrase

2020-01-18T19:51:34Z

Joshua Henslee: /* Two-Factor Seed Phrases */

A '''seed phrase''', '''seed recovery phrase''' or '''backup seed phrase''' is a list of words which correspond to the master private key of a Bitcoin SV wallet. In typical usage, a wallet will generate a seed phrase and instruct the user to write it down on paper. If the user's computer breaks or their hard drive becomes corrupted, they can download the same wallet software again and use the paper backup to deterministically re-generate their wallet. Seed phrases are the most frequently encountered means of backing up Bitcoin SV wallets.

Anybody with access to the phrase can steal the bitcoins, so it must be kept safe. Phrases should not be transmitted electronically and should never be written on any website.

== Example ==

An example of a seed phrase is:

witch collapse practice feed shame open despair creek road again ice least

The word order is important.

== Explanation ==

A simplified explanation of how seed phrases work is that the wallet software has a list of words taken from a dictionary, with each word assigned to a number. The words in the seed phrase are each converted to their corresponding number and concatenated to generate the seed integer to a [[Deterministic wallet|deterministic wallet]]. From this seed integer the wallet generates all [[Private Keys|key pairs]] used in the wallet.

The English-language wordlist for the BIP39 standard has 2048 words, so if the phrase contained only 12 random words, the number of possible combinations would be 2048^12 = 2^132 and the phrase would have 132 bits of security. However, some of the data in a BIP39 phrase is not random (see: [https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki#Generating_the_mnemonic BIP39: Generating the mnemonic]), so the actual security of a 12-word BIP39 seed phrase is only 128 bits.

== Two-Factor Seed Phrases ==

Several wallets enable their users to generate seed phrases with an added layer of encryption to prevent someone who discovers the words from accessing the wallet. The password can be used to create a two-factor seed phrase where both ''"something you have"'' plus ''"something you know"'' is required to recover the wallet.

This works by the wallet creating a seed phrase and asking the user for a password. Then both the seed phrase and extra word are required to recover the wallet. [https://electrumsv.io/ ElectrumSV] and some other wallets call the passphrase a '''"seed extension"''', '''"extension word"''' or '''"13th/25th word"'''. The BIP39 standard defines a way of passphrase-protecting a seed phrase. A similar scheme is also used in the Electrum SV standard. If a passphrase is not present, an empty string "" is used instead.

== Storing Seed Phrases for the Long Term ==

Most people write down phrases on paper but they can be stored in many other ways such as [[Brainwallet|memorizing]], engraving on metal, writing in the margins of a book or any other creative and inventive way.

For storing on paper writing with pencil is much better than pen [http://www.joethorn.net/blog/2011/12/07/pencil-does-not-fade Pencil Does Not Fade] [https://www.quora.com/How-do-I-maintain-a-paper-notebook-that-can-remain-for-years How do I maintain a paper notebook that can remain for years?]. Paper should be acid-free or archival paper, and stored in the dark avoiding extremes of heat and moisture [https://www.loc.gov/preservation/care/deterioratebrochure.html Essential facts about preservation of Paper] [https://www.quora.com/If-I-write-with-a-pencil-on-my-notebook-will-the-writing-last-for-a-long-time-say-50-years-or-will-it-just-fade-away-gradually Writing in a notebook with pencil] [http://copar.org/bulletin14.htm CoPAR: Creating records that will last] .

== Word Lists ==

Generally a seed phrase only works with the same wallet software that created it. If storing for a long period of time it's a good idea to write the name of the wallet too.

The BIP39 English word list has each word being uniquely identified by the first four letters, which can be useful when space to write them is scarce.

* [https://github.com/bitcoin/bips/blob/master/bip-0039/bip-0039-wordlists.md BIP39 wordlists]
* [https://github.com/spesmilo/electrum/blob/1.9.8/lib/mnemonic.py Electrum old-style wordlist]
* [https://github.com/spesmilo/electrum/blob/master/electrum/wordlist/english.txt Electrum new-style wordlist]

== Alternative name "Mnemonic Phrase" ==

Seed phrases are sometimes called "mnemonic phrases" especially in older literature. This is a bad name because the word mnemonic implies that the phrase should be memorized. It is less misleading to call them seed phrases.

== The power of backups ==

An especially interesting aspect in the power of paper backups is allowing your money to be two places at once. You can store backups on multiple devices/physical media in different locations and with password encryption. With that one can carry $100,000 which can instantly be moved to a phone or transferred yet with total security. If it's stolen then there is no risk because it is backed up elsewhere. That is powerful. [https://www.reddit.com/r/Bitcoin/comments/2hmnru/poll_do_you_use_paper_wallets_why_why_not_what]

== See Also ==

* [[Deterministic wallet]]
* [[Brainwallet]]

The Bitcoin Network

2020-01-18T19:50:49Z

Joshua Henslee: /* Thin SPV Clients */

Bitcoin SV uses a simple broadcast network to propagate transactions and blocks. All communications are done over TCP. Bitcoin SV is fully able to use ports other than 8333 via the -port parameter. IPv6 is [https://bitcointalk.org/index.php?topic=81378.0 supported] with all versions later than Bitcoind/Bitcoin-Qt v0.7.

== Messages ==
* ''version'' - Information about program version and block count. Exchanged when first connecting.
* ''verack'' - 'Version Acknowledgement'. Sent in response to a version message to acknowledge that the peer is willing to connect.
* ''addr'' - List of one or more IP addresses and ports.
* ''inv'' - "I have these blocks/transactions: ..." Normally sent only when a ''new'' block or transaction is being relayed. This is only a list, not the actual data.
* ''getdata'' - Request a single block or transaction by hash.
* ''merkleblock'' - Request a filtered block using the inventory type MSG_MERKLEBLOCK. Normally used to communicate transaction data to an SPV client.
* ''getblocks'' - Request an ''inv'' of all blocks in a range.
* ''getheaders'' - Request a ''headers'' message containing all block headers in a range.
* ''tx'' - Send a transaction. This is sent only in response to a ''getdata'' request.
* ''block'' - Send a block. This is sent only in response to a ''getdata'' request.
* ''headers'' - Send up to 2,000 block headers. Non-generators can download the headers of blocks instead of entire blocks.
* ''getaddr'' - Request an ''addr'' message containing a bunch of known-active peers (for bootstrapping).
* ''mempool'' - Requests TXIDs of transactions that the receiving node has validated but has not appeared in a block.
* ''submitorder'', ''checkorder'', and ''reply'' - Used when performing an [[IP Transactions|IP transaction]].
* ''alert'' - Send a network alert.
* ''ping'' - Does nothing. Used to check that the connection is still online. A TCP error will occur if the connection has died.
* ''pong'' - the pong message replies to a ping message, proving to the pining node that the ponging node is still responsive.
* ''notfound'' - Reply to a 'getdata' message which requested an object not available for relay.
* ''reject'' - Informs the receiving node that one of it's previous messages has been rejected.
* ''sendheaders'' - Indicates that the node prefers to receive new block announcements via 'headers' as opposed to 'inv' messages.
* ''feefilter'' - Tells the receiving peer not to send any transactions that do not meet the specified fee rate.
* ''sendcmpct'' - Indicates that a node is wiling to receive new block announcements via 'cmpctblock' message rather than an 'inv'.
* ''cmpctblock'' - Contains a 'CBlockHeaderAndShortTxIDs' object providing a header and list of short txids.
* ''getblocktxn'' - Block transactions request used to request a list transaction by specifying their indexes and block hash.
* ''blocktxn'' - Block transaction message provides the transactions requested by a 'getblocktxn' message.
* ''protoconf'' - Sent after 'verack' message, regardless of the peer's protocol version.

More information and in-depth technical information is in the [https://github.com/bitcoin-sv/bitcoin-sv/blob/a64b6a349a68207477ec8848c9c8c025d249fe35/src/protocol.h Protocol Specification].

== Connection ==

To connect to a peer, you send a ''version'' message containing your version number, block count, and current time. The remote peer will send back a ''verack'' message and his own ''version'' message if he is accepting connections from your version. You will respond with your own ''verack'' if you are accepting connections from his version.

The time data from all of your peers is collected, and the median is used by Bitcoin for all network tasks that use the time (except for other version messages).

You then exchange ''getaddr'' and ''addr'' messages, storing all addresses that you don't know about. ''addr'' messages often contain only one address, but sometimes contain up to 1000. This is most common at the beginning of an exchange.

== Standard relaying ==

When someone sends a transaction, they send an ''inv'' message containing it to all of their peers. Their peers will request the full transaction with ''getdata''. If they consider the transaction valid after receiving it, they will also broadcast the transaction to all of their peers with an ''inv'', and so on. Peers ask for or relay transactions only if they don't already have them. A peer will never rebroadcast a transaction that it already knows about, though transactions will eventually be forgotten if they don't get into a block after a while. The sender and receiver of the transaction will rebroadcast, however.

Anyone who is generating will collect valid received transactions and work on including them in a block. When someone does find a block, they send an ''inv'' containing it to all of their peers, as above. It works the same as transactions.

Everyone broadcasts an ''addr'' containing their own IP address every 24 hours. Nodes relay these messages to a couple of their peers and store the address if it's new to them. Through this system, everyone has a reasonably clear picture of which IPs are connected to the network at the moment. After connecting to the network, you get added to everyone's address database almost instantly because of your initial ''addr''.

Network alerts are broadcast with ''alert'' messages. No ''inv''-like system is used; these contain the entire alert. If a received alert is valid (signed by one of the people with the private key), it is relayed to all peers. For as long as an alert is still in effect, it is rebroadcast at the start of every new connection.

== Initial block download ==

At the start of a connection, you send a ''getblocks'' message containing the hash of the latest block you know about. If the peer doesn't think that this is the latest block, it will send an ''inv'' that contains up to 500 blocks ahead of the one you listed. You will then request all of these blocks with ''getdata'', and the peer will send them to you with ''block'' messages. After you have downloaded and processed all of these blocks, you will send another ''getblocks'', etc., until you have all of the blocks.

== Thin SPV Clients ==

Simplified Payment Verification was introduced as part of the Bitcoin whitepaper. [https://github.com/bitcoin/bips/blob/master/bip-0037.mediawiki BIP 0037] introduced support for thin or lite clients by way of Simple Payment Verification. SPV clients do not need to download the full block contents to verify the existence of funds in the blockchain, but rely on the chain of block headers and bloom filters to obtain the data they need from other nodes. This method of client communication allows high security trustless communication with full nodes, but at the expensive of some privacy as the peers can deduce which addresses the SPV client is seeking information about.

The desktop wallet [https://electrumsv.io/ ElectrumSV] works in this fashion using the Python library [https://github.com/kyuupichan/bitcoinX/tree/master/bitcoinx bitcoinX] as their foundation. [https://www.moneybutton.com/ Moneybutton] on the other hand uses [https://github.com/moneybutton/bsv Javascript Bitcoin SV library] for client communication.

== Bootstrapping ==

You choose which peers to connect to by sorting your address database by the time since you last saw the address and then adding a bit of randomization.

Bitcoin has three methods of finding peers.

=== Addr ===

The ''addr'' messages described above create an effect similar to the IRC bootstrapping method. You know reasonably quickly whenever a peer joins, though you won't know for a while when they leave.

Bitcoin SV comes with a list of addresses known as "seed nodes". If you are unable to connect to IRC and you've never connected to the network before, the client will update the address database by connecting to one of the nodes from this list.

The -addnode command line option can be used to manually add a node. The -connect option can force bitcoin to connect only to a specific node.

=== DNS ===

Bitcoin SV looks up the IP Addresses of several host names and adds those to the list of potential addresses. This is the default seeding mechanism, as of v0.6.x and later.

=== IRC ===

As-of version 0.6.x of the Bitcoin client IRC bootstrapping is no longer enabled by default, and as of version 0.8.2 support for IRC bootstrapping has been removed completely. The information below is accurate for most versions prior.

Bitcoin joins a random channel between #bitcoin00 and #bitcoin99 on irc.lfnet.org. Your nick is set to an encoded form of your IP address. By decoding all the nicks of all users on the channel, you get a list of all IP addresses currently connected to Bitcoin.

== Heartbeat ==

If thirty minutes or more has passed since the client has transmitted any messages it will transmit a message to keep the connection to the peer node alive.

If ninety minutes has passed since a peer node has communicated any messages, then the client will assume that connection has closed.

== See Also ==

* [[Peer-to-Peer Network Architecture]]
* [[Exchanging "Inventory"]]
* [[Encrypted and Authenticated Connections]]
* [[Transaction Pools]]
* [[Protocol|Protocol Specification]]
* [http://bitcoinstatus.rowit.co.uk/ Historical Network Status (no longer updated)]
* [http://getaddr.bitnodes.io/ Bitnodes.io's network size estimate]
* [http://fullnode.info/howto.html How to run your own cheap full bitcoin node]
* [https://www.bitcoinmining.com/ Bitcoin Mining]
* [https://www.youtube.com/watch?v=GmOzih6I1zs Video: What is Bitcoin Mining]

[[Category:Technical]]

Difficulty

2020-01-18T19:48:45Z

Joshua Henslee: /* What is the maximum difficulty? */

''See also: [[Target]]''

=== What is difficulty? ===

Difficulty is a measure of how difficult it is to find a hash below a given [[target]]. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the [[Genesis block|Genesis Block]]?"

The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target.
Mining pools also have a pool-specific share difficulty setting a lower limit for shares.

=== How often does the network difficulty change? ===

See [[Target|target]].

=== What is the formula for difficulty? ===
difficulty = difficulty_1_target / current_target

''target is a 256 bit number''

''difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.''

difficulty_1_target can be different for various ways to measure difficulty.
Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff").
The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (this is known as "bdiff").

===How is difficulty stored in blocks?===

Each block stores a packed representation in its block header (called [[Block hashing algorithm|Bits]]) for its actual hexadecimal [[target]]. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:
0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

Note that the 0x0404cb value is a signed value in this format. The largest legal value for this field is 0x7fffff. To make a larger value you must shift it down one full byte. Also 0x008000 is the smallest positive valid value.

===How is difficulty calculated? What is the difference between bdiff and pdiff?===

The highest possible target (difficulty 1) is defined as 0x1d00ffff, which gives us a hex target of
0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

It should be noted that pooled mining often uses non-truncated targets, which puts "pool difficulty 1" at
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

So the difficulty at 0x1b0404cb is therefore:
0x00000000FFFF0000000000000000000000000000000000000000000000000000 /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.420938523983 (bdiff)
And:
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.669773817162 (pdiff)

Here's a fast way to calculate bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:

<source lang="cpp">
#include <iostream>
#include <cmath>

inline float fast_log(float val)
{
int * const exp_ptr = reinterpret_cast <int *>(&val);
int x = *exp_ptr;
const int log_2 = ((x >> 23) & 255) - 128;
x &= ~(255 << 23);
x += 127 << 23;
*exp_ptr = x;

val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
return ((val + log_2) * 0.69314718f);
}

float difficulty(unsigned int bits)
{
static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));
}

int main()
{
std::cout << difficulty(0x1b0404cb) << std::endl;
return 0;
}
</source>

To see the math to go from the normal difficulty calculations (which require large big ints bigger than the space in any normal integer) to the calculation above, here's some python:

<source lang="python">
import decimal, math
l = math.log
e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))))
print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3)))
print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8)
</source>

=== What is the current difficulty? ===
[https://whatsonchain.com/ Current difficulty]

=== What is the maximum difficulty? ===

There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).

The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately it never will, so we're ok.)

The difficulty can rise by a maximum of 400% of the current difficulty, or by a factor of 4.

=== Can the network difficulty decrease? ===
Yes it can. See discussion in [[target]].

The network's difficulty can adjust downwards by up to 75% of the current difficulty.

=== What is the minimum difficulty? ===
The minimum difficulty, when the target is at the maximum allowed value, is 1. This is the difficulty of the [[Genesis block]].

=== What network hash rate results in a given difficulty? ===
The difficulty is adjusted every 2016 blocks based on the [[Block_timestamp|time]] it took to find the previous 2016 blocks. At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find. If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced. If they took less than two weeks, the difficulty is increased. The change in difficulty is in proportion to the amount of time over or under two weeks the previous 2016 blocks took to find.

To find a block, the hash must be less than the target. The hash is effectively a random number between 0 and 2**256-1. The offset for difficulty 1 is
0xffff * 2**208
and for difficulty D is
(0xffff * 2**208)/D

The expected number of hashes we need to calculate to find a block with difficulty D is therefore
D * 2**256 / (0xffff * 2**208)
or just
D * 2**48 / 0xffff

The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds. That means the hash rate of the network was
D * 2**48 / 0xffff / 600
over the previous 2016 blocks. Can be further simplified to
D * 2**32 / 600
without much loss of accuracy.

At difficulty 1, that is around 7 Mhashes per second.

At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found the average network hash rate was
22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.

=== How soon might I expect to generate a block? ===
The average time to find a block can be approximated by calculating:
time = difficulty * 2**32 / hashrate
where difficulty is the current difficulty, hashrate is the number of hashes your miner calculates per second, and time is the average in seconds between the blocks you find.

For example, using Python we calculate the average time to generate a block using a 1Ghash/s mining rig when the difficulty is 20000:
$ python -c "print 20000 * 2**32 / 10**9 / 60 / 60.0"
23.85
and find that it takes just under 24 hours on average.

Remember - any one grinding of the hash stands the same chance of "winning" as any other. The numbers game is how many attempts hardware can make per second.

==Related Links==

* See also: [[Target]]

Difficulty

2020-01-18T19:48:02Z

Joshua Henslee: /* Can the network difficulty go down? */

''See also: [[Target]]''

=== What is difficulty? ===

Difficulty is a measure of how difficult it is to find a hash below a given [[target]]. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the [[Genesis block|Genesis Block]]?"

The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target.
Mining pools also have a pool-specific share difficulty setting a lower limit for shares.

=== How often does the network difficulty change? ===

See [[Target|target]].

=== What is the formula for difficulty? ===
difficulty = difficulty_1_target / current_target

''target is a 256 bit number''

''difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.''

difficulty_1_target can be different for various ways to measure difficulty.
Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff").
The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (this is known as "bdiff").

===How is difficulty stored in blocks?===

Each block stores a packed representation in its block header (called [[Block hashing algorithm|Bits]]) for its actual hexadecimal [[target]]. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:
0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

Note that the 0x0404cb value is a signed value in this format. The largest legal value for this field is 0x7fffff. To make a larger value you must shift it down one full byte. Also 0x008000 is the smallest positive valid value.

===How is difficulty calculated? What is the difference between bdiff and pdiff?===

The highest possible target (difficulty 1) is defined as 0x1d00ffff, which gives us a hex target of
0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

It should be noted that pooled mining often uses non-truncated targets, which puts "pool difficulty 1" at
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

So the difficulty at 0x1b0404cb is therefore:
0x00000000FFFF0000000000000000000000000000000000000000000000000000 /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.420938523983 (bdiff)
And:
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.669773817162 (pdiff)

Here's a fast way to calculate bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:

<source lang="cpp">
#include <iostream>
#include <cmath>

inline float fast_log(float val)
{
int * const exp_ptr = reinterpret_cast <int *>(&val);
int x = *exp_ptr;
const int log_2 = ((x >> 23) & 255) - 128;
x &= ~(255 << 23);
x += 127 << 23;
*exp_ptr = x;

val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
return ((val + log_2) * 0.69314718f);
}

float difficulty(unsigned int bits)
{
static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));
}

int main()
{
std::cout << difficulty(0x1b0404cb) << std::endl;
return 0;
}
</source>

To see the math to go from the normal difficulty calculations (which require large big ints bigger than the space in any normal integer) to the calculation above, here's some python:

<source lang="python">
import decimal, math
l = math.log
e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))))
print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3)))
print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8)
</source>

=== What is the current difficulty? ===
[https://whatsonchain.com/ Current difficulty]

=== What is the maximum difficulty? ===

There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).

The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately it never will, so we're ok.)

=== Can the network difficulty decrease? ===
Yes it can. See discussion in [[target]].

The network's difficulty can adjust downwards by up to 75% of the current difficulty.

=== What is the minimum difficulty? ===
The minimum difficulty, when the target is at the maximum allowed value, is 1. This is the difficulty of the [[Genesis block]].

=== What network hash rate results in a given difficulty? ===
The difficulty is adjusted every 2016 blocks based on the [[Block_timestamp|time]] it took to find the previous 2016 blocks. At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find. If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced. If they took less than two weeks, the difficulty is increased. The change in difficulty is in proportion to the amount of time over or under two weeks the previous 2016 blocks took to find.

To find a block, the hash must be less than the target. The hash is effectively a random number between 0 and 2**256-1. The offset for difficulty 1 is
0xffff * 2**208
and for difficulty D is
(0xffff * 2**208)/D

The expected number of hashes we need to calculate to find a block with difficulty D is therefore
D * 2**256 / (0xffff * 2**208)
or just
D * 2**48 / 0xffff

The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds. That means the hash rate of the network was
D * 2**48 / 0xffff / 600
over the previous 2016 blocks. Can be further simplified to
D * 2**32 / 600
without much loss of accuracy.

At difficulty 1, that is around 7 Mhashes per second.

At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found the average network hash rate was
22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.

=== How soon might I expect to generate a block? ===
The average time to find a block can be approximated by calculating:
time = difficulty * 2**32 / hashrate
where difficulty is the current difficulty, hashrate is the number of hashes your miner calculates per second, and time is the average in seconds between the blocks you find.

For example, using Python we calculate the average time to generate a block using a 1Ghash/s mining rig when the difficulty is 20000:
$ python -c "print 20000 * 2**32 / 10**9 / 60 / 60.0"
23.85
and find that it takes just under 24 hours on average.

Remember - any one grinding of the hash stands the same chance of "winning" as any other. The numbers game is how many attempts hardware can make per second.

==Related Links==

* See also: [[Target]]

Difficulty

2020-01-18T19:47:42Z

Joshua Henslee: /* Can the network difficulty go down? */

''See also: [[Target]]''

=== What is difficulty? ===

Difficulty is a measure of how difficult it is to find a hash below a given [[target]]. Difficulty answers the question: "how many times more difficult is it to mine a block now, compared with how difficult it was to mine the [[Genesis block|Genesis Block]]?"

The Bitcoin network has a global block difficulty. Valid blocks must have a hash below this target.
Mining pools also have a pool-specific share difficulty setting a lower limit for shares.

=== How often does the network difficulty change? ===

See [[Target|target]].

=== What is the formula for difficulty? ===
difficulty = difficulty_1_target / current_target

''target is a 256 bit number''

''difficulty_1_target is the target used in the Genesis Block and represents a difficulty of 1.''

difficulty_1_target can be different for various ways to measure difficulty.
Traditionally, it represents a hash where the leading 32 bits are zero and the rest are one (this is known as "pool difficulty" or "pdiff").
The Bitcoin protocol represents targets as a custom floating point type with limited precision; as a result, Bitcoin clients often approximate difficulty based on this (this is known as "bdiff").

===How is difficulty stored in blocks?===

Each block stores a packed representation in its block header (called [[Block hashing algorithm|Bits]]) for its actual hexadecimal [[target]]. The target can be derived from Bits via a predefined formula. For example, if the packed target in the block is 0x1b0404cb, the hexadecimal target is:
0x0404cb * 2**(8*(0x1b - 3)) = 0x00000000000404CB000000000000000000000000000000000000000000000000

Note that the 0x0404cb value is a signed value in this format. The largest legal value for this field is 0x7fffff. To make a larger value you must shift it down one full byte. Also 0x008000 is the smallest positive valid value.

===How is difficulty calculated? What is the difference between bdiff and pdiff?===

The highest possible target (difficulty 1) is defined as 0x1d00ffff, which gives us a hex target of
0x00ffff * 2**(8*(0x1d - 3)) = 0x00000000FFFF0000000000000000000000000000000000000000000000000000

It should be noted that pooled mining often uses non-truncated targets, which puts "pool difficulty 1" at
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

So the difficulty at 0x1b0404cb is therefore:
0x00000000FFFF0000000000000000000000000000000000000000000000000000 /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.420938523983 (bdiff)
And:
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF /
0x00000000000404CB000000000000000000000000000000000000000000000000
= 16307.669773817162 (pdiff)

Here's a fast way to calculate bitcoin difficulty. It uses a modified Taylor series for the logarithm (you can see tutorials on flipcode and wikipedia) and relies on logs to transform the difficulty calculation:

<source lang="cpp">
#include <iostream>
#include <cmath>

inline float fast_log(float val)
{
int * const exp_ptr = reinterpret_cast <int *>(&val);
int x = *exp_ptr;
const int log_2 = ((x >> 23) & 255) - 128;
x &= ~(255 << 23);
x += 127 << 23;
*exp_ptr = x;

val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
return ((val + log_2) * 0.69314718f);
}

float difficulty(unsigned int bits)
{
static double max_body = fast_log(0x00ffff), scaland = fast_log(256);
return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));
}

int main()
{
std::cout << difficulty(0x1b0404cb) << std::endl;
return 0;
}
</source>

To see the math to go from the normal difficulty calculations (which require large big ints bigger than the space in any normal integer) to the calculation above, here's some python:

<source lang="python">
import decimal, math
l = math.log
e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))))
print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3)))
print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3)))
print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2)
print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8)
</source>

=== What is the current difficulty? ===
[https://whatsonchain.com/ Current difficulty]

=== What is the maximum difficulty? ===

There is no minimum target. The maximum difficulty is roughly: maximum_target / 1 (since 0 would result in infinity), which is a ridiculously huge number (about 2^224).

The actual maximum difficulty is when current_target=0, but we would not be able to calculate the difficulty if that happened. (fortunately it never will, so we're ok.)

=== Can the network difficulty go down? ===
Yes it can. See discussion in [[target]].

The network's difficulty can adjust downwards by up to 75% of the current difficulty.

=== What is the minimum difficulty? ===
The minimum difficulty, when the target is at the maximum allowed value, is 1. This is the difficulty of the [[Genesis block]].

=== What network hash rate results in a given difficulty? ===
The difficulty is adjusted every 2016 blocks based on the [[Block_timestamp|time]] it took to find the previous 2016 blocks. At the desired rate of one block each 10 minutes, 2016 blocks would take exactly two weeks to find. If the previous 2016 blocks took more than two weeks to find, the difficulty is reduced. If they took less than two weeks, the difficulty is increased. The change in difficulty is in proportion to the amount of time over or under two weeks the previous 2016 blocks took to find.

To find a block, the hash must be less than the target. The hash is effectively a random number between 0 and 2**256-1. The offset for difficulty 1 is
0xffff * 2**208
and for difficulty D is
(0xffff * 2**208)/D

The expected number of hashes we need to calculate to find a block with difficulty D is therefore
D * 2**256 / (0xffff * 2**208)
or just
D * 2**48 / 0xffff

The difficulty is set such that the previous 2016 blocks would have been found at the rate of one every 10 minutes, so we were calculating (D * 2**48 / 0xffff) hashes in 600 seconds. That means the hash rate of the network was
D * 2**48 / 0xffff / 600
over the previous 2016 blocks. Can be further simplified to
D * 2**32 / 600
without much loss of accuracy.

At difficulty 1, that is around 7 Mhashes per second.

At the time of writing, the difficulty is 22012.4941572, which means that over the previous set of 2016 blocks found the average network hash rate was
22012.4941572 * 2**32 / 600 = around 157 Ghashes per second.

=== How soon might I expect to generate a block? ===
The average time to find a block can be approximated by calculating:
time = difficulty * 2**32 / hashrate
where difficulty is the current difficulty, hashrate is the number of hashes your miner calculates per second, and time is the average in seconds between the blocks you find.

For example, using Python we calculate the average time to generate a block using a 1Ghash/s mining rig when the difficulty is 20000:
$ python -c "print 20000 * 2**32 / 10**9 / 60 / 60.0"
23.85
and find that it takes just under 24 hours on average.

Remember - any one grinding of the hash stands the same chance of "winning" as any other. The numbers game is how many attempts hardware can make per second.

==Related Links==

* See also: [[Target]]

Main Page

2020-01-18T19:44:21Z

Joshua Henslee: /* Unit of account */

[[Special:UserLogin|Temporary log in link]]

Welcome to the BitcoinSV wiki. Here we aim to provide a correct and up-to date set of information on the Bitcoin network and its features and functionality.

===Bitcoin===

'''Bitcoin''' is a peer to peer cash system created by [https://craigwright.net/ Dr. Craig Wright] under the pseudonym [[Satoshi Nakamoto]] and released as open-source software in 2009. It does not rely on a central server to process transactions or store funds. The leaderless structure of the network famously solves [[The Byzantine Generals Problem]] allowing disconnected entities to follow a common direction without centralised instruction.

===The Ledger===
The Bitcoin ledger is also formed as a DAG where each transaction is a node. Following this graph back can trace every the ownership of every coin in an unbroken chain of signatures back to the original [[Coinbase]] transactions.
The ledger is held on a [https://en.wikipedia.org/wiki/Distributed_networking distributed network] of nodes who compete with each other to extend it.

Miners gather transactions from the network and evaluate whether they want to mine them or not.

[[GetBlockTemplate interface|Block templates]] are created by a node which calculates the root of a [https://en.wikipedia.org/wiki/Merkle_tree Merkle tree] containing all of the transactions they are attempting to mine. As new transactions arrive, they are added to the tree.

===Nodes===
Nodes are operated by the [[Mining|Bitcoin mining enterprises]] who build the network. Bitcoin's economic incentives are structured such that for the nodes to be most profitable at building the ledger they must be as closely connected to other well performing nodes as possible. This leads to miners forming a [[Small World Network]] which trends towards a [[Nearly Complete Graph]] where all miners are connected to all other miners. Miners gather transactions from users who connect in a layered network over the nodes at the core forming a [[Mandala Network]]. In this shell network, peers use [[Simplified Payment Verification]] to form a much less densely packed structure where information is exchanged in [[Payment Channels]].

As Bitcoin scales, the nodes who comprise the network will be variously compartmentalised into specialised hardware. These clustered systems will be distributed globally, each being placed in a location optimised for its task.

===Proof of Work===
The miners use hash based [[Proof of Work]] to compete for the right to extend the ledger, and as a means to vote on [[Network|network rules]].

===Unit of account===
[[Satoshis]] are the ledger's native unit of account and 100,000,000 satoshis is abstracted to one Bitcoin. Satoshis are held in script puzzles called [[UTXO|Unspent Transaction Outputs or UTXOs]]. These are [[VOUT|outputs]] from [[Bitcoin Transactions]] which are held by miners in a quick access database called the UTXO set. During the spending process, UTXOs being used in a transaction are consumed and the solution to their puzzle script is recorded in the transaction.

===Subsidy===
Satoshis are issued by miners to themselves as a [[Block subsidy|subsidy payment]] during the network establishment phase. As the network matures, the the subsidy dissipates forcing the miners to find alternate revenue streams. The payment allows miners to finance their operations through the payment of goods and services in Bitcoin, spreading them through the economy.

===Transactions===
All transactions are [[Payments in Bitcoin|payments]]. Transactions are written in a flexible [[Opcodes used in Bitcoin Script|scripting language]] that is used to assign ownership rights to each transaction output.
All network events including the creation of a block are inscribed in transactions.

Valid transactions that are broadcast on [[The Bitcoin Network]] are committed to the Bitcoin public ledger by miners in [[Block|Blocks]]. Blocks are discovered just under every 10 minutes on average and held in a a [[wikipedia:Directed Acyclic Graph|Directed acyclic graph]] (DAG) structured as a [[Block chain]]. Each block forms a node in the graph. This graph is consistent in structure and can be traced back to the [[Genesis block|first block mined]].

Transactions can be exchanged peer to peer, allowing them to be modified in payment channels. Once a transactions is sent to the network in a closed channel, global [[consensus|Consensus]] can be reached on the validity in less than 2 seconds.

===Network rules===
Bitcoin operates on a fixed ruleset. consensus is based on things such as the rate at which new bitcoins are issued, the mathematical rules outlining the target for the [[Difficulty]] algorithm and more. The protocol is agreed upon by the miners who control network operation.

===Limits===
There are no limits in the [[Protocol|Bitcoin protocol]]. Any limits imposed are are put in place by miners who are incentivised to catch the largest profitable pools of transactions they can. Miners compete to offer better service to fee paying users by scaling their own capabilities.

===History===
[[Bitcoin until today|Bitcoin has a rich history]] and has been [[Attacks on Bitcoin|attacked]] in many ways since its inception.

===Tools and Building on Bitcoin===
Bitcoin has a rich and diverse [[Building on Bitcoin|set of tools]] which are being added to all the time.

Main Page

2020-01-18T19:44:04Z

Joshua Henslee: /* Proof of Work */

[[Special:UserLogin|Temporary log in link]]

Welcome to the BitcoinSV wiki. Here we aim to provide a correct and up-to date set of information on the Bitcoin network and its features and functionality.

===Bitcoin===

'''Bitcoin''' is a peer to peer cash system created by [https://craigwright.net/ Dr. Craig Wright] under the pseudonym [[Satoshi Nakamoto]] and released as open-source software in 2009. It does not rely on a central server to process transactions or store funds. The leaderless structure of the network famously solves [[The Byzantine Generals Problem]] allowing disconnected entities to follow a common direction without centralised instruction.

===The Ledger===
The Bitcoin ledger is also formed as a DAG where each transaction is a node. Following this graph back can trace every the ownership of every coin in an unbroken chain of signatures back to the original [[Coinbase]] transactions.
The ledger is held on a [https://en.wikipedia.org/wiki/Distributed_networking distributed network] of nodes who compete with each other to extend it.

Miners gather transactions from the network and evaluate whether they want to mine them or not.

[[GetBlockTemplate interface|Block templates]] are created by a node which calculates the root of a [https://en.wikipedia.org/wiki/Merkle_tree Merkle tree] containing all of the transactions they are attempting to mine. As new transactions arrive, they are added to the tree.

===Nodes===
Nodes are operated by the [[Mining|Bitcoin mining enterprises]] who build the network. Bitcoin's economic incentives are structured such that for the nodes to be most profitable at building the ledger they must be as closely connected to other well performing nodes as possible. This leads to miners forming a [[Small World Network]] which trends towards a [[Nearly Complete Graph]] where all miners are connected to all other miners. Miners gather transactions from users who connect in a layered network over the nodes at the core forming a [[Mandala Network]]. In this shell network, peers use [[Simplified Payment Verification]] to form a much less densely packed structure where information is exchanged in [[Payment Channels]].

As Bitcoin scales, the nodes who comprise the network will be variously compartmentalised into specialised hardware. These clustered systems will be distributed globally, each being placed in a location optimised for its task.

===Proof of Work===
The miners use hash based [[Proof of Work]] to compete for the right to extend the ledger, and as a means to vote on [[Network|network rules]].

==Unit of account==
[[Satoshis]] are the ledger's native unit of account and 100,000,000 satoshis is abstracted to one Bitcoin. Satoshis are held in script puzzles called [[UTXO|Unspent Transaction Outputs or UTXOs]]. These are [[VOUT|outputs]] from [[Bitcoin Transactions]] which are held by miners in a quick access database called the UTXO set. During the spending process, UTXOs being used in a transaction are consumed and the solution to their puzzle script is recorded in the transaction.

===Subsidy===
Satoshis are issued by miners to themselves as a [[Block subsidy|subsidy payment]] during the network establishment phase. As the network matures, the the subsidy dissipates forcing the miners to find alternate revenue streams. The payment allows miners to finance their operations through the payment of goods and services in Bitcoin, spreading them through the economy.

===Transactions===
All transactions are [[Payments in Bitcoin|payments]]. Transactions are written in a flexible [[Opcodes used in Bitcoin Script|scripting language]] that is used to assign ownership rights to each transaction output.
All network events including the creation of a block are inscribed in transactions.

Valid transactions that are broadcast on [[The Bitcoin Network]] are committed to the Bitcoin public ledger by miners in [[Block|Blocks]]. Blocks are discovered just under every 10 minutes on average and held in a a [[wikipedia:Directed Acyclic Graph|Directed acyclic graph]] (DAG) structured as a [[Block chain]]. Each block forms a node in the graph. This graph is consistent in structure and can be traced back to the [[Genesis block|first block mined]].

Transactions can be exchanged peer to peer, allowing them to be modified in payment channels. Once a transactions is sent to the network in a closed channel, global [[consensus|Consensus]] can be reached on the validity in less than 2 seconds.

===Network rules===
Bitcoin operates on a fixed ruleset. consensus is based on things such as the rate at which new bitcoins are issued, the mathematical rules outlining the target for the [[Difficulty]] algorithm and more. The protocol is agreed upon by the miners who control network operation.

===Limits===
There are no limits in the [[Protocol|Bitcoin protocol]]. Any limits imposed are are put in place by miners who are incentivised to catch the largest profitable pools of transactions they can. Miners compete to offer better service to fee paying users by scaling their own capabilities.

===History===
[[Bitcoin until today|Bitcoin has a rich history]] and has been [[Attacks on Bitcoin|attacked]] in many ways since its inception.

===Tools and Building on Bitcoin===
Bitcoin has a rich and diverse [[Building on Bitcoin|set of tools]] which are being added to all the time.

Building on Bitcoin

2020-01-18T19:41:52Z

Joshua Henslee:

===Introduction===
Bitcoin's ability to store data on the blockchain enables any and all types of applications to be built on top of it. With a defined, locked down protocol and immutable transactions Bitcoin enables robust applications that can inter-operate with each other paving the way for limitless use-cases. Additionally, the flexible [[VOUT#Unspent_Transaction_Outputs|UTXO]] model of storing transactions paves the way for massive scale-ability, instilling confidence that the Bitcoin SV network can handle the transaction volume that robust applications require.

===Popular tools===
* [https://neon.planaria.network/#/ Neon Planaria] - Javascript framework that generates a state machine and database as well as an API to interface other applications with.
* [https://bitbus.network/docs#/ Bitbus] - Creates a filtered subledger of Bitcoin transactions in your file system, eliminating the need for application developers to run a node.
* [https://github.com/unwriter/datapay Datapay] - Simple JS library that enables broadcasting of Bitcoin transactions with as little as 4 lines of code.
* [https://www.moneybutton.com Moneybutton] - Robust payment API where users swipe a button to generate a Bitcoin transaction for payment and/or write data to the blockchain.
* [https://www.cashport.io Cashport] - API framework that enables developers to easily manage and implement micro-payments for services in your application.
* [https://www.bsvalias.org Paymail] - Protocol that defines how to send Bitcoin to a human readable, email like namespace instead of a Bitcoin address.
* Contact Brendan Lee at b.lee@bitcoinassociation.com to have your stable tool added.

Further information about how to practically build on top of Bitcoin can be found here:

#[[Bitcoin Test Blockchains]]
#[[Bitcoin wallet libraries]]
#[[The Metanet]]
#[[BSVAlias]]
#[[Application layer protocol]]
#[[Advanced Bitcoin Scripting]]
#[[Payment Channels]]

Smart contracts

2020-01-17T17:48:06Z

Joshua Henslee:

===Introduction===
A smart contract is a self executing contract where terms of the contract are implemented in code. A common misconception is that Bitcoin is incapable of executing smart contracts, paving the way for the creation of other blockchains like [https://ethereum.org/ Ethereum].

Bitcoin Script as originally implement is capable of simple yet powerful smart contracts that can be written, deployed and deferred to the miners on the network for execution.

===Smart contract platforms===
[http://scrypt.studio/ sCrypt] is a web-based integrated development environment (IDE) where developers can implement Bitcoin script in a higher level, more familiar programming language.

[https://github.com/gear-sv GearSV] is a means of writing and running smart contracts on the Bitcoin SV network. Leveraging other development tools, contracts can be deployed on-chain as data, then run and validated off-chain by oracles or software agents.

Contact Brendan Lee at b.lee@bitcoinassociation.com to have your smart contract platform added.

Smart contracts

2020-01-17T17:47:22Z

Joshua Henslee:

===Introduction===
A smart contract is a self executing contract where terms of the contract are implemented in code. A common misconception is that Bitcoin is incapable of executing smart contracts, paving the way for the creation of other blockchains like [https://ethereum.org/ Ethereum].

Bitcoin Script as originally implement is capable of simple yet powerful smart contracts that can be written, deployed and deferred to the miners on the network for execution.

===Smart contract platforms===
[http://scrypt.studio/ sCrypt] is a web-based integrated development environment (IDE) where developers can implement Bitcoin script in a higher level, more familiar programming language.

[https://github.com/gear-sv GearSV] is a means of writing and running smart contracts on the Bitcoin SV network. Leveraging other development tools, contracts can be deployed on-chain as data, then run and validated off-chain by oracles or software agents.

To have your smart contract platform added, please contact Brendan Lee (b.lee@bitcoinassociation.net).