Calculation of Bitcoin private key using it's generation time

No, the time when the key was generated is entirely irrelevant. A private key is essentially a random number and with a robust source of randomness the time it takes to generate this random number is completely independent of the random number generated. For example, if we both run the same random number generator for exactly 5 minutes we should each generate completely different random numbers. With a flawed source of randomness we may both generate the same random number after exactly 5 minutes but this source of randomness should not be used for generating private keys.


How do I calculate the expected shares per minute for my pool

I was able to find some information from this page...

https://arxiv.org/abs/1112.4980

I think I was able to figure out the formula, but somebody please correct me if I am wrong. The formula is not very difficult, but you must know the number of hashes that correspond to a minimum difficulty of 1 (share difficulty). This is easy to find for some currencies (bitcoin, 2^32), but very difficult to find for others. For Zencash, it is 8192 or 2^13. The formula to determine the expected blocks per minute for Zencash is:

  blocks_per_time = (hashrate * seconds) / (8192 * block_difficulty)

In our case, the estimated blocks per minute would be:

(50000 * 60) / (8192 * 764414.6217) = 4.791e-4 blocks/min.

Then if we know it takes an average of 764,414.6217 difficulty-1 shares to solve a block, then we can calculate the pool's shares/min as:

  shares_per_min = blocks_per_min * block_difficulty

shares_per_min = 4.791e-4 * 764414.6217 = 366.2.

Or, we can simplify the original equation to estimate the given shares/min in a pool based on a given pool hashrate as:

  shares_per_min = (hashrate * 60 seconds) / 8192

shares_per_min = (50000 * 60) / 8192. = 366.2

Based on this (and the reason I wanted to know the answer to this question), you can see that if you stop mining on a PPLNS pool with a steady hashrate of 50 kH/s where n=20000, you're estimated reward should fall to zero after about 54 minutes. Of course, your shares are very likely submitted at a higher difficulty than one, but this shouldn't affect that calculation.


Where can I get a list of upcoming features for NXT? and whats on the way for 2014?

On the NXT-Wiki you can find a list of planned features which are currently in development. Here some examples:

Voting System
Instant Transactions
Automated Transactions
Multisignature transactions
Shrinking (reduce size of Blockchain)

For a more detailed release plan, I guess you need to check the project sites of specific features.


rpc_pb2_grpc is an official lnd API. This is a low-level interface that supports essentially all the same calls you can make through lncli. If you decide to use this one - I can suggest you start with this official tutorial.

lnd_grpc is a third-party wrapper on top of rpc_pb2_grpc, which introducing additional level of abstraction and hides some things from the user (such as handling protocol buffer messages and stubs). It is easier to use for most of the cases, but it is not official and it is less flexible than rpc_pb2_grpc.

Naturally, if you use the latter library - you should open issues in their GitHub, since they are not affiliated with the lnd devs.

Regardless of what you use - I think the error you are getting is related to the fact that you start lnd with the --no-macaroons option.


Why did the Bitminter application ruin my GPU?

Mining itself don't ruin the GPU, but the long usage. A GPU's lifespan is at least 3-5 years. When working continuously on high freq. it is decreased as well.
  Whoop in your case, your card just got 'burned'
It is not a the mining itself that caused the damage, but there is something else, or software, or the GPU was not quite on her place, or maybe some malicious software helped you for the achievement.


SPV clients don't fully validate blocks. Therefore, they are vulnerable to being fed a fake block from their full node peers. A fraud proof is a way to prove that a chain tip is invalid. As soon as any node would discover a block to be invalid, they'd create and relay a fraud proof to the network. As SPV clients receive the fraud proof they will know not to accept the invalid block.

As hinted above, fraud proofs can be created by any network participant that discovers an invalid block. As far as I know, this has nothing to do with Segregated Witness, but will rather be introduced as an independent softfork some time in the future.


How to use "lockunspent" in bitcoin core wallet console?

The problem is, you should to escape the inner quotes:

lockunspent false "[{\"txid\":\"c3fa34606ae3ea416ff640d97414ef6a0a8afcebfbe2c60403ad60c0d961f04c\",\"vout\":0}]"


What is the current computing speed of performing an elliptic curve multiplication?

The only way to determine the private key associated with a given public key is by a brute force method, spanning the entire 2^256 key space. More specifically, any number from 0x1 to 0xFFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFE BAAEDCE6 AF48A03B BFD25E8C D0364140 (order of G) is a valid private key.

According to an article on wikipedia on brute force cryptography, it would take 50 supercomputers that could check 10^18 keys per second about 3x10^51 years to exhaust the 256 bit key space. However, this number fails to account for theoretical limits of energy consumption and computation from Landauer's principle. I decided to put in some work to show the theoretical limits.

  Landauer's Principle

Laundauer's principle basically provides us with the lower limit of energy consumption needed to flip a bit as a function of temperature (it is much more complex, but we can leave that aside for now.) That lower limit is given by the formula: kT * ln(2) (where k is the Boltzmann constant (1.38*10^-23) and T is temperature in Kelvin scale.) So, for a 2^256 key space, that energy is 2^256*kT*ln(2). The energy that I'm calculating below, is only to generate keys in the 2^256 key space, and does not involve the energy to generate public keys from them and check the result.

Since I'm in Mumbai, I will take the liberty to use temperature of 25 degree celsius or 298 Kelvin. Using the above formula, E = 2^256*kT*ln(2), we get energy as 3.3x10^56. According to this article, the global electricity consumption was 21,700 TWh in 2017. That's equivalent to 7.8*10^19 Joules. So, even assuming that world's entire electricity supply is diverted to generation of the keys in 256-bit key space, we would still need electricity that is 5*10^36 times more than that is generated today.


How to access my bitcoin on a new wallet?

to tool up how much it is…

…although its should not have changed much since back then )

you can easily look up the address if you wrote it down.

just replace with your address: https://blockchain.info/address/1C3RiLE1M5BsGHH5GDhTwjTmYquawd6aKj

and of course there are many other site that do the job of a "blockexplorer" if you need a term to search for.

prices you will find on market places and exchanges like poloniex or kraken.

to actually use the funds

you'll need a wallet software that can read your private key format and can either create a transaction to be transmitted or send it to the network directly. you will find a list to start with: https://www.weusecoins.com/en/find-the-best-bitcoin-wallet/ and some other places like the bitcoin wiki and other forums will give much more.

To convert private key formats you can use – for actual private keys with an offline copy – tools like e.g.

bitaddress.org (source)
iancoleman's BIP39 (source) – this is a good starting point to dive deeper as newer BIPs are implemented that enable you for usage of e.g. SegWit enabled addresses.

I cannot recommend you anything without knowing what is your device/operating system etc.


There's a start and an end that can be quoted, and only one is required although both can be used.

If you want US$ per BTC data from a 24th April until now until now, use:

http://bitcoincharts.com/t/trades.csv?symbol=mtgoxUSD&start=1366784293

If you want all US$ per BTC data until now, use:

http://bitcoincharts.com/t/trades.csv?symbol=mtgoxUSD&start=1279424500

If you want all US$ per BTC data until 24th April 2013,:

http://bitcoincharts.com/t/trades.csv?symbol=mtgoxUSD&start=1279424500&end=1366784293


What happens in a small scale blockchain network?

If you were using a fork of Bitcoin Core, your small scale network would not work.

Assuming you did the basic chain parameter modification or just firewall yourself from the rest of the Bitcoin network, there are two major things that are missing: peer discover, and mining.

Bitcoin Core by default uses a process called DNS Seeding in order to discover seed nodes. If those seeders fail, it will fall back to using some hard coded seed nodes. However, these are seed nodes which are treated differently than normal nodes (even though they are still normal nodes). Seed nodes are only connected to in order to get a list of more nodes to connect to. It is nodes on that list that are eventually connected to for actual normal node operations. Your node disconnects from those seed nodes once they get this list.

So, for your network, you would need to potentially run your own DNS seeders and seed nodes. But that's actually not really necessary. You would just need to disable DNS seeding and the hardcoded seed nodes, then just have everyone on your network set multiple connect=<ip> lines in their configuration files where <ip> is the IP address of a node. This will force the node to connect only to the specified nodes. Note that this will disable further node discovery and automatic node connection, so if you add someone else to your network, not all of the other nodes will connect to the newcomer unless they are explicitly added.

The other problem will be mining. Bitcoin Core does not contain any mining logic at all. It does not automatically mine nor does it even have the ability to produce blocks. Instead you will need to install some other mining software. However, because CPU and GPU mining are pointless, you will have to build, and potentially modify, those mining software yourself in order to enable CPU and GPU mining. Otherwise you will need to get some mining hardware supported by those software. Without using any mining software, your network will not produce any blocks and no transactions will be confirmed.


Why MultiBit replays transactions from internet on every startup?

MultiBit remembers the last blockheight that it saw in the wallet.

There are various times where, if it sees discrepancies across the wallets (or compared to the Bitcoin network) it goes back in time to get the transactions again. This is is to prevent inconsistencies and to deal with forks etc.

It goes back in time using a checkpoints file, which is included in the installer. As 0.5.14 is a couple of months old now it goes back a bit further in time than is ideal. I update the checkpoints file in every build.


At the beginning. when nobody owned bitcoins. what was being minned?

The first blocks were completely empty and didn't contain any transactions.
The first transaction was in block 170 from Satoshi to Hal Finney, as seen here.

As newly generated coins from mined blocks are only spendable after 100 blocks, the earliest possible block to spend the first coins would have been at block 101.

It is completely legit to mine empty blocks (even if there are pending unconfirmed transactions). Here is an example of an empty block on April 2017.


Ubuntu command to download https://launchpad.net/~bitcoin/+archive/bitcoin/+packages

It's relatively painless

sudo apt-add-repository add-repository
sudo apt-get update
sudo apt-get install bitcoin-qt

How you get rid of the old copy depends on how it was installed, if it was a default install this will probably get rid of that anyway.


I had a horrendus time doing this because of the fact that the jar is not available in a public site. Their docs to install it in a local repo and point maven at it seemed promising, but in the end I can tell you the best way:

Start by forking a Java Maven project. Instructions to do that are here: http://java.heroku.com/
Clone your project.
Clone bitcoinj from git.
Copy the dependencies from the pom.xml of both the top level project from bitcoinj, AND the one in the 'core' directory into your project's pom.xml. You'll also have to include some version numbers which are set in properties in the pom.xml to make it work.
Copy everything from bitcoinj/core/main/src/java/ into your project.
Assuming you've done all this, you should now be able to compile your project, including bitcoinj which you copied in from step 5 into your project, because you copied all the required dependencies into your pom.xml in step 4.
Make a main class with a main method and get a static network parameters for production, make a block chain, a block store, and a peer group, and wire those up. Make a new wallet and a new ECKey, add the key to the wallet and the wallet to the block chain.
Modify your pom.xml to point the appassembler plugin at your main class so it runs when you deploy the app.
git push heroku master
Send yourself some coins, watch your wallet onCoinsRecieved fire.


I think you are talking about the consensus rules and when they are enforced...

To get the whole picture I would suggest to read about this topic in the book "Mastering Bitcoin" by Andreas Antonopoulos.

https://github.com/bitcoinbook/bitcoinbook/blob/develop/ch10.asciidoc#decentralized-consensus


How can i consult my transaction history via Bitcoind/JsonRPCClient?

Wow, sorry guys, for some reason i checked like 3 times all of the Bitcoind commands and didn't see it, but here it is:

listtransactions [account] [count=10] [from=0]

Returns up to [count] most recent transactions skipping the first [from] transactions for account [account]. If [account] not provided will return recent transaction from all accounts.


Is there any other protocol in use besides a "Gossip protocol"

If you want to read more about the p2p protocol, check out the Bitcoin Developer Guide's overview of all peer-to-peer messages. Besides transaction and block relay, it is used to announce node services, discover peers, communicate content preferences, and request specific content. Only blocks and transactions are gossiped. Node addresses are shared with connections that ask for them. The remaining messages are just for communication on specific connections. Note that other software may support additional messages not supported by the reference client, e.g. to serve UTXO data, or to fulfill service-specific light client requests.
FIBRE is a redundant second communication network for relaying newly mined blocks outside of the regular gossip. It used especially by miners and large Bitcoin services.
Mining pools use their own protocols (getblocktemplate, stratum, stratumv2) to coordinate contributions of their contributors.
The LN uses a whole separate stack of protocols to announce channels and nodes, manage peers, channels, and facilitate payments.
I am not sure whether the following strictly fulfill the definition of "protocols", but there are various coordination processes to facilitate multiparty payments such as PSBT, statechains, MuSig, JoinMarket, PayJoin, …

Hope that's sort of what you were looking for, but note that the list is not meant to be exhaustive. Please feel free to amend your question to further narrow down what you are looking for, if I am off target.


What are the transactions included in the merkle root

How do I specify my unique address?

You don't need to. Bitcoin will add the coinbase transaction automatically.

  Does it depend on what kind of miner I use

No.

  and whether I mine in a pool?

Yes, because then the pool gives you a block header to mine, which includes their coinbase transaction. If you put in your own coinbase header, then the pool will reject your shares.

  Also what is "generation" and how is it different from other transactions that include transfers of bitcoins?

Just like a normal transaction, it specifies how the money can be spent, but unlike normal transactions, it doesn't need to provide any inputs. However, the amount transferred must be equal to the total transaction fees plus the block subsidy.

  What other transactions are included in the Merkle root?

Every valid transaction that your bitcoin client knows about is included.

  I suppose that the pool gives different headers which include different transactions to pool members. Right?

I'm not sure what you mean by that - the coinbase transaction is different, because the pool doesn't want multiple miners to duplicate work. But in all cases, the coinbase transaction gives the bitcoins to the pool. Actually solving a block is worth just as much to the individual miner as solving a share.

  What happens to the transactions that are not included. Are they included in future blocks?

Sometimes. Maybe those transactions are forgotten. It's called the "memory pool" for a reason - it's forgotten on shutdown.


Has UTXO selection methods changed since activation of Segwit?

Bitcoin Core's client has recently applied changes to their coin selection algorithms based on Murch's Master's thesis.


An exchange doesn't set a price at all. It provides a framework for customers to buy and sell coins to each other, at whatever prices the buyers and sellers find mutually agreeable. The exchange itself does not buy or sell, and the prices it quotes are just a report of what its customers are doing  right now.


How to find address that holds the balance in Bitcoin Core?

The listunspent RPC command will provide a list of all unspent outputs in your wallet, along with the addresses.


sp20 jackson vs Bitmain Antminer S7 for personal bitcoin mining

You are overlooking a very important part of the costs, that you already mentioned. The energy!

Roughly at 13.0 cents per Kw/h your yearly energy costs are:

Scenario one:

21 x 1.2Kw x 24h x 365d x $0.13 = $28697.76 USD! you are down quite a bit.

Scenario two:

6 x 1.293Kw x 24h x 365d x $0.13 = $8834.81 USD! you are down a bit less but still not enough..

So the only way you will make $$ its that BTC value raises in price, in which you are better off just buying off BTC right now for whatever value you are planning to spend.

You need to add into account that mining difficulty will rise and payouts will be even less.

Hopefully this brief info helps you decide (I was a miner myself 2 years ago)

Best of luck!


Can I claim my bitcoin gold if I have used my bitcoins few days ago?

You should be able to claim your Bitcoin Gold with your private key. The snapshot of ownership for Bitcoin Gold was taken on October 25th, if you had bitcoins at that time, you'll get Bitcoin Gold.

In order to redeem it, you'll need to import your seed/private key in a Bitcoin Gold wallet, but beware of fake wallets that just want to steal your coins.


Lnd - how to open a double-funded channel

What you ask for is called dual funded channels as both peers would found the channel. All implementations will eventually have this feature as it has been agreed to include it to BOLT 1.1. I think c Lightning has done most progress on dual funded channels (in particular Lisa neigut has a branch working on it)


New Numbers: How many Bitcoin addresses are/have been carrying a balance?

Though, I don't have the exact number, an approximate number can be inferred from the number of unspent transaction output set or UTXO.

Each address with non zero balance will have an entry in UTXO. These days wallet create new address for each payment, so commonly addresses have one txout. However, most people reuse addresses and are used for donation, go through mixers etc and they end up with multiple UTXO.

Taking an approximate number of 2 UTXO per address.  This factor approximately matches with the number of addresses calculated in 2012 and the UTXO values for 2012 in the blockchain.info chart

For 2017, looking up from blockchain.info UTXO chart gives

47.3 million /2  ~ 23.6 million address


How is the Merkle Tree sequentially propagated, and are the parts addressed?

The Merkle tree isn't included in the download data.  Just the root hash is included in the block header.  The client has to reconstruct the tree in order to verify the root hash.  It does this by going through the transaction list as it appears in the block data.  Each transaction hash is a node at the top of the tree.  So, if you have 6 transactions, you have 6 nodes (the last transaction hash is repeated if you have an odd number of nodes).  Then the next level of the tree is computed where each node is formed by hashing the two nodes above it (again, the last node is duplicated if you have an odd number).  This process continues until you have just one node - the root node.  It is checked against the root in the header to make sure it matches.  If it does, you know the transactions have not been modified.  Note that the block hash is only over the block header and does not include the transactions themselves.

Here is an example with 6 transactions (Tx1-Tx6)

Tx1    Tx2    Tx3    Tx4    Tx5    Tx6
    \   /        \    /        \   /
     L2A -      -  L2B          L2C -     - L2C (repeated)
          \    /                     \   /
            L3A  ---            ----  L3B
                    \          /
                         Root


Is it possible to schedule function calls to an Ethereum smart contract?

This feature can be easily realised outside the Ethereum virtual machine (and thus keeping the VM simple): Create a (reusable) contract where contracts can register to be called at a certain time (and provide a reward as compensation for the gas costs). A script can poll this contract from outside and call it at the appropriate times. The contract could be similar to the following.

contract CallbackRegistry
{
  struct Entry { uint time; address addr; bytes data; uint reward; }
  mapping(bytes32 => Entry) entries;
  function register(uint _time, address _addr, bytes _data) external returns (bytes32 _hash)
  {
    _hash = sha3(_time, _addr, _data);
    entries[_hash].time = _time;
    entries[_hash].addr = _addr;
    entries[_hash].data = _data;
    entries[_hash].reward = msg.value;
  }
  function invoke(bytes32 _hash) external
  {
    if (entries[_hash].time > 0 && now >= entries[_hash].time)
    {
      msg.sender.send(entries[_hash].reward);
      entries[_hash].addr.call(entries[_hash].data);
      delete entries[_hash];
    }
  }
}


Why is the block header 80 bytes, not 128 bytes (= two SHA-256 blocks)?

It could have been done that way, at the cost of increasing the amount of space it takes to store and send block headers. It seems like block header storage was a big concern for Satoshi, (there's even a section in the whitepaper about it) but it's turned out to not matter very much.

  Does this mean the 2nd SHA block is padded with 64 - 16 = 48 bytes?

Yes, (source) but your reasoning is flawed. Even if the nonce space were so large that it extended into another block, that would just mean that midstate would represent the state after hashing all but the last block (block in the cryptography sense, not the Bitcoin sense.)

Also, if the block header were exactly 128 bytes, the padding would extend it to a third block. You only have 119 bytes before that happens.

  That way, extranonce doesn't have to be in the generation transaction, thereby speeding up hashing, no?

Not really. You can check 2^32 hashes before incrementing extranonce, after which you only need to do ten or so hashes before you get back to mining.

Generally, in modern ASICs, even that part has been offloaded. There will be some sort of small processor within the ASIC, like an ARM core, which takes a block template as input and outputs block headers for the SHA256 cores to work on.

So the cost isn't one of speed, but complexity.

Like many things in Bitcoin, I think this is a technical decision that made sense at the time, but aged poorly.


Missing Deposit in my bitcoin core account

Depends on which wallet you 'bought' the coins. If it was a paper wallet/ mobile app wallet/ some other wallet software, then obviously it won't come up in the Bitcoin core wallet software. Just FYI, Bitcoin core comes coupled with a lot of other utilities apart from making you machine act as a full node. It has a built in wallet whose balance and other details are accessible via the command line interface, bitcoin-cli or the GUI bitcoin-qt.

Assuming you did not use the Bitcoin core wallet, you need to first import the private and public keys to get the balance. You can go through the API documentation of the bitcoin core. The following links might be useful

Import address

Import private key

Import wallet


Does bitcoin have the potential to be subject to a hard fork where miners are forced to choose which fork they will accept, like Etherum?

Yes, Bitcoin could also be subjected to a hardfork. In fact, there are members of the Bitcoin community that feel so strongly that the blocksize should be increased that they are proposing to do just that:
They are working on a version of Bitcoin that is incompatible in regard to the current consensus rules of Bitcoin forcing a permanent split of the blockchain into two. They surmise that their vision for Bitcoin will have greater support than the road map followed by the Bitcoin Core developers and expect to oust the original chain completely.

As they (IMHO) appear to overestimate the support for their project, I don't expect the latter to come to pass.

As Mindwin has pointed out in the comment rightly so, the Bitcoin blockchain has actually forked before by accident: See march-2013-fork, or Bitcoin Magazine's report.
There have also been previous forking attempts, such as the ones pushed for by Bitcoin-XT and Bitcoin Classic.


2 transaction in same address - Please help

The address you linked has received two payments, if you control the private keys for that address then you have nothing to worry about, those coins are in your control.

Generally, it is not best practices to reuse an address, as it is very bad for your privacy (and, potentially the privacy of your customers). However, in terms of being able to spend the coins later, there is no technical issue with receiving more than one payment to an address.

You should be able to spend the two UTXOs as normal.


Find all transactions for a bitcoin address

To use getrawtransaction to lookup any transaction, you have to have the -txindex flag set, so that all transactions are indexed. But, you have to know the txid.

getrawtransaction "txid" ( verbose "blockhash" )

NOTE: By default this function only works for mempool transactions. If the -txindex option is
enabled, it also works for blockchain transactions. If the block which contains the transaction
is known, its hash can be provided even for nodes without -txindex. Note that if a blockhash is
provided, only that block will be searched and if the transaction is in the mempool or other
blocks, or if this node does not have the given block available, the transaction will not be found.

I would recommend using an api such as blockchain.info

Single Address

https://blockchain.info/rawaddr/$bitcoin_address
Address can be base58 or hash160
Optional limit parameter to show n transactions e.g. &limit=50 (Default: 50, Max: 50)
Optional offset parameter to skip the first n transactions e.g. &offset=100 (Page 2 for limit 50)

{
    "hash160":"660d4ef3a743e3e696ad990364e555c271ad504b",
    "address":"1AJbsFZ64EpEfS5UAjAfcUG8pH8Jn3rn1F",
    "n_tx":17,
    "n_unredeemed":2,
    "total_received":1031350000,
    "total_sent":931250000,
    "final_balance":100100000,
    "txs":[--Array of Transactions--]
}

What you want is in the txs property of the returned json object.


Armory Wallet With 2BTC Gone After 3 Years! HELP!

Try searching the address at blockchain.info with the following link

https://blockchain.info/address/<your_addres_here>

It will give the current balance of that address, the transactions it was involved. Just in case if your bitcoins were transferred somewhere you would know.


It's worth noting that bitcoins would have no value if it weren't for speculation.  When Satoshi first released the client, those who put their electricity and computing resources towards mining bitcoins were speculating that the value would rise from zero, and that the coins would be accepted as payment by someone else.  Those who first accepted bitcoin payments, likewise, were speculating that the value would remain above zero, and continue to be accepted by others, and so on.

It's also worth noting that Bitcoin would likely not have received the amount of attention that it has if not for people speculating that the value would rise tremendously and buying coins in large quantities.  This attention has brought in more users, developers, and businesses, thus increasing the health of Bitcoin.

If speculation does hurt Bitcoin in some ways, it's at the very worst a necessary evil.


If Blockchain miners weren't paid would there still be trust in all bitcoin transactions?

Trust would remain in Bitcoin transactions only if miners continued to mine. However, without a financial incentive, there would be no reason for them to shoulder the high electricity costs of mining.


Block finding is random. The number of blocks in a period of time follows the Poisson distribution. If the average is 10 minutes per block, then the chance of at least 9 blocks in a given 24 minute period is roughly 0.086%. Not a lot but it can happen occasionally. Also, if momentarily the hashrate has increased without the difficulty catching up, the rate, and the probability, will be higher.
Yes, 6 confirmations that due to luck took, say, 30 minutes, are even safer than 6 confirmations that took 60 minutes, since the attacker would have had less time to find blocks in his alternative branch.


Getting paid by BitCoin on my website using Credit Card

cant think of a direct way.

merchant CC service
have them direct deposit to https://www.bitwage.com/

i doubt the connection will work since most merchant accounts will want to be able to pull funds from a bank in the event of a charge back.  but you merchant acct may decide to hold on to funds to make up for the loss.

might be better to get your customer to sign up for circle, coinbase/gdax, gemini, localbitcoins or one of the many other exchanges and have them send you bitcoin.


Is there a way to give `bitcoin-cli` a different default conf directory instead of specifying it each time?

In this case I would create an alias?
$ alias BCLI="bitcoin-cli -conf=/media/btc/bitcoin/bitcoin.conf"
$ BCLI getblockcount

On Windows you may use doskey.


Unfortunately, there is not much you can do.

By design, it is very difficult to identify a person from a Bitcoin address. In principle, if the thief eventually  transfers the coins to an exchange in order to sell them, it could be possible to trace  the coins to that point, and the exchange might know who got the money. But they would probably not divulge this without a court order (if even then), and they may be in a different country with different laws. Moreover, the thief could use a mixing service or other techniques to make it much more difficult to trace the coins to the exchange.

The IP address is a little better (yours is missing some dots, by the way). You can use a tool such as whois to find the ISP to whom the address is registered, and their records would show which of their subscribers was using it at that time. But again, you'd need a court order, and they could be in a different country. Furthermore, there's a very good chance that the thief is not actually their subscriber, but someone who compromised their subscriber's computer and used it remotely. There could even be several layers of this.

Each of these steps would need the assistance of law enforcement, so it would be reasonable to report the theft to your local or national police agency, and give them the information you've shared with us. (It could take some work to educate them about Bitcoin, or find an officer who is already familiar with it.) But unless      the thief has done a shoddy job of covering his tracks, it's unlikely he'll be caught, and even less likely that you'll be able to recover your coins.

Sorry.


If you look at recent blocks on https://blockstream.info/ (as of today, Aug 15 2020), nearly all blocks are very close to 4000 kWU. The variation is due to availability of sufficiently small transactions to fill up the last part, and differences in selection algorithms.
Occasionally, an empty block appears instead. These happen as a result of pools learning about a new block faster than they can construct a new template on top, and inform all their hashers. Instead, the instantly tell everyone to start working on an empty block (which is definitely valid), and only when a new full block template is constructed do they inform the hashers of it. This is exacerbated by validationless mining, where the pool may learn about the new block hash tip, before actually having even seen the new block.
So, as far as I can see, in recent times with sufficient pressure for demand, effectively all blocks are full, except for empty ones occasionally.


How to generate recovery phrase from private key

Firstly, it is highly recommended not to use a brainwallet, your coins will be stolen.

But in general, if you have a private key, there is no way to obtain the 12 word recovery phrase from it. That is because the 12 word phrase is used as a seed to generate a hierarchical deterministic master extended private key, as described in BIP 39 and BIP 32 and this process is not reversible. Also, your private key is not an extended private key which is needed for an HD wallet, so the best you can do is simply import that single address manually. Some wallets do not support importing of individual addresses for safety, because they wouldn't be covered by the 12 word mnemonic backup. So I would suggest just generating a new wallet and everything and forgetting about your brain wallet.


It look like a permission read/write error, if you are sure about the bitcoin binary you are using, then try to run your command with sudo at the begining of it or try a sudo chmod 711 /etc/systemd/system/bitcoind.service which will give the proper right to the file you want to use.


Unlocking a Private Key from watch status

First, confirm that you did indeed receive a private key.  On Bitcoin mainnet, private keys are almost always distributed in a format that starts with either a K or an L (capitalized in either case) and are usually 52 alphanumeric characters long.  Here's an example:

L3SD2fM9hzVJyr4zxoHqXHDqHTVfQpbLuWDVm6b6W7PTCSYpkujd

If you instead received a code starting with a 1, a 3, or bc1, then what you received was an address.  If you received a hexadecimal code that was 130 characters long and started with 04 or 66 characters long and starting with 02 or 03, then what you received was a public key.  None of those are private keys, and there's no way to get the private key from an address or a public key.  Here are some examples of addresses and public keys:

1GWLEdJRaMTQSe7NkPAfBCZaR1XdTz4dct
3DXNLK83EiMsseHTfGySGvDL64CKpRTf6G
bc1q4gtqryu6dhs4vzwqwp9fjxegc4rmxcx6shn3qs
03d8f40442a837693820c4ca35bff30036af4df79c5563375200313462086b6d31

If you have any other type of information, that's probably also not a private key and it may have nothing specific to do with Bitcoin.

If you do indeed have a private key, you can import it into most Bitcoin wallets.  See the documentation for your specific wallet for instructions (if you can't find the documentation for importing private keys, feel free to ask a separate question).

You don't need any special information to "unlock a private key".  In addition, the normal way to receive mining profits is by a normal Bitcoin payment to one of your addresses; I've never before heard of any mining pool paying profits by distributing private keys as that has all the same costs plus a large additional security risk.  It seems likely to me that the person you're communicating with is attempting to steal money from you, so be careful in your dealings with them.


How does the getblocktemplate request rate correlate with a miner's hashrate?

There's no relationship. With a single block template mining software can create a limitless amount of work by modifying the extranonce, the only reason they would need to update to a new one is to include transactions that have just arrived, or when someone else has found a block. The reason GetWork rates varied was that each request was only valid for a single 2**32 nonce range, which a modern ASIC miner can exhaust in milliseconds.


On https://bitcoin.org/en/exchanges, you can find exchanges of many countries. For Mexico, https://bitso.com and https://www.volabit.com are listed. Both allow for conversion between MXN and BTC.


Are there any POS coin open source mobile wallets implementations?

AFAIU, PoS is considered flawed by large parts of the cryptocurrency community.

I've not kept abreast of POS coins, but some that I could think of are Peercoin, NXT and Blackcoin, which are currently ranked 38, 39, and 58 on Coinmarketcap.

Unless I'm missing some new more popular ones, I'd say there is less software for them because they have less of an ecosystem / they are less popular?


Running Bitcoin Core (bitcoind or bitcoin-qt) already means running a node.
You don't need to set it up.
The addnode function is used to manually add a connection to another node.
This is not something necessary, unless you have specific reasons to connect to a particular node (e.g. a node you trust).
This function does not return any object (although executed successfully), which is why get null in return.
getnodeaddresses returns a random subset of node addresses known to your node.
As for the RPC methods, generateprivkey does not exist, while the error for createrawtransaction is probably due to a wrong input format (you are missing the squared brackets in the second object)
The correct format is:
[{"txid":"id","vout":n},...] [{"address":amount},{"data":"hex"},...]

Also note that you won't be able to create a transaction without having the corresponding keys in your wallet.


How to create the   part in "scriptSig"?

First question has a long answer, because it depends on the scriptPubKey, but also of the sigHash flag, I assume you are speaking about classic P2PKH transactions. (ScriptPubKey expose the condition for "unlocking", while ScriptSig satisfies them for "unlocking". It can use signature... or not, but will assume you are using P2PKH scriptPubKey, so it does)

So the scriptPubKey is

OP_DUP OP_HASH160 <PubkeyHash> OP_EQUALVERIFY OP_CHECKSIG

Where PubkeyHash is given by your bitcoin address.

The scriptSig should be

<Sig> <PubKey>

The PubKey is simple. From your Private key, you can get the public key (curve secp256k1)

Q = dG

where d private key : int, Q public key : EC Point, G : ECPoint given by curve.

<sig>

is composed of 2 components

<ecdsaSig> <sigHash>

ECDA Sig is the signature of a hash of the transaction in DER encoding. sigHash is a byte that specifies how to generate this hash (ie: what is actually signed).

sigHash itself contains 2 informations.

<AnyoneCanPay><All|None|Single>

So what is signed is a calculated hash of your transaction depending on the sigHash. The human friendly explanation is here, and the most readable code doing that is here.

Once you calculated the hash, you need to sign it according to this math on elliptic curves.
Due to the need in the algorithm of a random K value, it supposes a fair RNG.
So RFC6979 describes a way for finding a K value that is not random but secure to use.  (implementation here)

So here is what is signed, depending on the sigHash you choose:

AnyoneCanPay : You allow someone to modify any input in the transaction. (don't sign inputs, except yours)

All : You deny modification of outputs in the transaction. (sign outputs)

Single : You deny modification of the output having the same index as you input (sign one output)

None : You allow modification of any output in the transaction. (sign no output)

Second question :
No, whatever the sigHash you use, part of your signature contains the previous output reference you are spending. Since you can't double spend, you can't reuse the signature.
However, if you really want to do that, then use the same K value for signing 2 different hashes, then you basically leaked your private key. So anyone would be able to "unlock" a future transaction made to your bitcoin address by knowing the two signatures.


Can i compose a multisig address where one of the signatories is a multisig address?

No this is not supported behavior. You can manually add the public keys from one multisig script into another, but a multisignature script can not be nested within another.


How do I generate the Bitcoin Cash hash preimage?

Bitcoin Cash uses BIP 143 for signature hash creation.

From the BIP:

  Double SHA256 of the serialization of:
     1. nVersion of the transaction (4-byte little endian)
     2. hashPrevouts (32-byte hash)
     3. hashSequence (32-byte hash)
     4. outpoint (32-byte hash + 4-byte little endian)
     5. scriptCode of the input (serialized as scripts inside CTxOuts)
     6. value of the output spent by this input (8-byte little endian)
     7. nSequence of the input (4-byte little endian)
     8. hashOutputs (32-byte hash)
     9. nLocktime of the transaction (4-byte little endian)
    10. sighash type of the signature (4-byte little endian)

So the hash preimage will look like this:

01000000be16f25831b40c713fed6627e39aa7717170f5cdd62c765bd4882abbefdaa50e3bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e70665044fb4a8e5c7ac5311f32fbe127f031134ee3e7490f3308ca19c567f78d6aa96d77000000001976a914ac599afa005a522e376334c6727e3c0f1aa6398688ac20a1070000000000ffffffffc8e2e71fe663fc91d7aa109feffee0f1497862af35525f68f500cbd55f6ed6620000000041000000

And here is its breakdown:

nVersion: 01000000
hashPrevouts: be16f25831b40c713fed6627e39aa7717170f5cdd62c765bd4882abbefdaa50e
hashSequence: 3bb13029ce7b1f559ef5e747fcac439f1455a2ec7c5f09b72290795e70665044
outpoint: fb4a8e5c7ac5311f32fbe127f031134ee3e7490f3308ca19c567f78d6aa96d7700000000
scriptCode: 1976a914ac599afa005a522e376334c6727e3c0f1aa6398688ac
value: 20a1070000000000
nSequence: ffffffff
hashOutputs: c8e2e71fe663fc91d7aa109feffee0f1497862af35525f68f500cbd55f6ed662
nLocktime: 00000000
sighash: 41000000


What is better for Bitcoin mining: More stream processors or faster clock?

Realistically, it's a multiplier of the two. You can make up for a slower clock with more cores and vice versa, but the number of hashes per second is dependent on both.

Sadly, I'm not aware of any specific formula to approximate hashes per second for a given clock speed and number of cores.

It's important to note, by the way, that the one thing that won't buy you more hashes per second is the complexity of the cores. This is why Nvidia may make great cards for gaming purposes, but they suck for mining - games make better use of exotic new instructions than SHA256 does.

Update: Thanks to the table David Schwartz linked to I've been able to estimate that a theoretical AMD GPU core running at 1 MHz can calculate approximately 300 hashes per second. Therefore we can estimate hashes/sec as Cores * Clock * 300. This isn't really all that exact and it seems to over-estimate some cards and under-estimate otheres, even within the same family so I'm guessing ambient temperature and other factors were interfering with test results, but it seems to be an ok estimate in most cases. YMMV. It also fails miserably with older cards, but those get such pathetic hash rates it probably doesn't matter anyway.


That means your results are being rejected. Most probably becouse someone else's found them before. Mining bitcoins at 100KH/s is useless, at 280GH/s 0.06BTC are mined daily so....


Why are chain parameters hardcoded rather than defined in a configuration file?

I don't think there's really any better reason than "Satoshi Nakamoto chose to write the code that way, and nobody ever changed it".

There's no inherent reason why these values couldn't be loaded from a configuration file, but there's a general principle that config files are intended for parameters that are user configurable.  A Bitcoin user couldn't change anything in that config file or their client would quit working with the rest of the network.  Developers might want to, but they are expected to be comfortable with recompiling.  So presumably nobody thought it was worthwhile to write the code to parse a config file for these values.

So if you want to be able to modify those values by editing a config file, you'll first have to write the code to parse and load the config file.  Which, of course, also involves recompiling (and a lot more work besides).  Perhaps now you can see why nobody has wanted to do it so far.  But if you do, you can offer the code back to the main Bitcoin Core development line, and maybe it will be incorporated, thus saving someone in the future from this quandary.

Recompiling Bitcoin Core is not all that much work, once you have a development environment and necessary dependencies installed.  And when you have compiled it once, changes to the chain parameters should only require you to recompile one file and relink (which Make will do automatically).


How can I get email notification when I get or make a Ripple payment?

Have a look at my service, Was I Paid?. It will send you an email on payment receipt, and in the future will support other types of events.


Proof of work: optimal number of transactions?

Given that the probability of finding the correct nonce will be marginally higher if you've already tested thousands of nonces for a given merkle root

This isn't true. No block header is guaranteed to return a solution. (In fact, most do not.) Each attempt to hash a block header is equally likely to result in a valid block, regardless of how many nonces have already been checked.


Why can the same 12 words produce different seeds in an Electrum wallet file?

It's actually a good question. Let's take a look at what is happening. First, Electrum hashes your mnemonic to generate a seed. The seed indeed contains all the information necessary to generate the Master Public Key and the Master Secret Key, first being used to generate the sequence of public keys (adresses) and the second being used to derive a secret key from a public key (actually it's slightly more complex). Then, Electrum saves the wallet file, which contains the seed and the keys being actually in use, the whole sequence of key pairs unless it hits 5 consecutive unused adresses. It can store it either unenrypted or encrypted. In the first case, the seed value in the file will always look the same, as will private keys. In the second case, however, they won't. Why? The Electrum documentation says:

  Electrum uses AES-256-CBC to encrypt the seed and private keys in the wallet.

What does it mean? AES-256 is simply a block cipher. It takes a block of data (128 bit in this case) and a block of key (256 bit) and outputs 128 bits of encrypted data. But it is not what Electrum does. Actually, noone uses block ciphers like that and noone ever should. Instead, so called modes are used. In our case it is Cipher Block Chaining (CBC) mode. Electrum first generates a random initialization vector (IV), mix it (by exclusive or operation) with first 128 bit of input and uses AES-256 on this mixed block to produce first encrypted block. For any subseqent block it does the same, except instead of IV it takes previous encrypted block to mix with the plaintext block. The IV is saved alongside with the file. Finally, that's why you always arrive with a different seed value in a file, even when using the same password (which results in the same key for AES-256-CBC encryption [1]) -- a different IV is used each time.

[1] It is not probably the case either, as Key Derivation Function is likely to be used to deliver a key from your passphrase, in which case additional random salt value is added to the passphrase before hashing it and saved alongside, similarly to the IV.


What do I need to know about mining difficulty before starting a bitcoin mining startup?

If you want to extrapolate what the difficulty will be in the future, here is a chart you can look at:

http://bitcoindifficulty.com/

The big thing about difficulty is that it's hard to predict. In general, it's almost always increasing due to better hardware, but it's hard to predict how much it'll increase because bitcoin hardware increases with innovation, something that's intrinsically hard to predict.

Generally, there's a lot of guesswork involved and forecasting to do as a businessman.


Running out of disk space with Bitcoin Core

How are you? WOW guessing you're rich now!
The proof you have bitcoin in your wallet does nothing. Bitcoin is not a system you can go and get your wallet back with showing them you have bitcoin in your wallet.
Go to blockchain.info and download the app. Click on add address. Scan your private key and then you can use your bitcoins again.
Hope you can gain access to your wallet.


Can Bitcoin(PoW) work under partial synchrony?

If I understand it correctly, this only proves it works in synchronous network. If so, this assumption seems relaxed to me.

The Bitcoin network is not synchronous, it is asynchronous and maintains consensus.

  Can Bitcoin protocol achieve consensus in partial synchronous network as well?

Since Bitcoin is an asynchronous network and achieves consensus, it stands to reason that Bitcoin would be able to achieve consensus in a synchronous or partially synchronous network as well.


How do you download blockchain data (transactions etc.) using a node? Best ways to get a node?

I am just curious how one can download bitcoin data and blockchain using a node

One way is to download and install a full-node desktop wallet such as Bitcoin-core.

When it is first started it will download the full blockchain. This may take a week - depending on your Internet-connection's bandwidth.

  Where should I start?

https://bitcoin.org/en/ is probably a reasonable place to start.

Ask questions here (one at a time) about any problems understanding or using Bitcoin. But use the search function here first - lots of great answers already exist for many problems.


Can the Bitcoin protocol support very small transactions effectively?

The answer is multifaceted.

Microtransactions were not a design goal of Bitcoin. Even if they're not well supported, that's ok.
Off-chain transactions might be used if on-chain microtransactions are too expensive.
There are a few possibilities to implement microtransactions on the blockchain. One such implementation was recently added to bitcionj. Also see this interesting proposal for nondeterministic nanopayments.
Alt chains for microtransactions are a viable solution as well.

TL;DR - it's not a problem.


How will bitcoin survive if everyone is hoarding?

The evidence suggests that there indeed quite a number of Bitcoin transaction, both people buying and selling. We can only speculate what they are buying and selling but there is a significant number of transactions.

bitinfocharts.com can show us the graphs for the number of transactions per day and the median value of those BTC transactions here - approximately 230,000 transactions yesterday with a median value of US$1,001 - that is a lot of money moving hands.

It is true that there are some who hoard, but not all.


Trying to find an efficient method to process all transactions directed to my BTC address

I have found the answer to my own question
To make sure every transaction goes through my script I have decided to use walletnotify. This is a feature of bitcoind and will run a bash script every time there is a new transaction with the transaction id. I was able to place this in my .bitcoin/bitcoin.conf file with the parameters like so:
walletnotify=/bin/echo %s | /bin/nc -U /root/nodejs.sock
I used netcat to bridge my requests from bash to NodeJS however you can use your %s transaction data any way you like.


What happens when the last added block in a blockchain is corrupted?

By definition a node's idea of the blockchain is among all valid versions of history the one with the most total proof of work.

Because chains are required to be valid, it is not possible to have a block in there that violates consensus rules. It doesn't matter what miners do; full nodes will still ignore the block entirely, as if it was never created.


I just published a book about it. It's called "Blockchain Programming in C#".

If you're looking for tools written in C#, you should try NBitcoin. You can also find the project on GitHub.

I've also written lots of articles about it:

Intro: http://www.codeproject.com/Articles/768412/NBitcoin-The-most-complete-Bitcoin-port-Part-Crypt
Stealth Payment, and BIP38: http://www.codeproject.com/Articles/775226/NBitcoin-Cryptography-Part
How to build transactions: http://www.codeproject.com/Articles/835098/NBitcoin-Build-Them-All
Using the NBitcoin Indexer: http://www.codeproject.com/Articles/819567/NBitcoin-Indexer-A-scalable-and-fault-tolerant-blo
How to Scan the blockchain: http://www.codeproject.com/Articles/784519/NBitcoin-How-to-scan-the-Blockchain (You can dismiss the ScanState for that, now I concentrate on the indexer)


Coinbase is built on top of Bitstamp. They may work with other exchanges now, but they are (and used to be) very tightly coupled with Bitstamp.

There was an exploit where someone discovered that Coinbase's price was set to the last sale price on Bitstamp.  Basically, this person would sell a small amount of Bitcoin for much lower than market value on Bitstamp.  Coinbases price would match that, where he'd buy again.

Coinbase does operate their own reserves as well, which (as others have pointed out) are used when Coinbase customers buy and sell within the site.  Their prices are set using a weighted average of multiple exchanges.


Your client won't show the transaction until it's received the block the transaction was included in. This website has the block count in the header: http://bitcoincharts.com/charts/

Right this moment, there are 164472 blocks (and I'm responding to your question quickly) so there's clearly still some downloading to do. Try to determine whether the block download is still occurring, and work from there. There should be a percentage complete figure for the block download in the bitcoin-qc client.


PoS (Proof of Stake) - Do you have to leave your wallet QT application open all the time to receive interest? mainly for the coin Philosopher stone

Short answer: Yes.
Long answer: To make your coins mature, all you have to do is wait but you need your wallet to be open and running the staking process, otherwise nothing's happening.


Will Schnorr Multi-signatures completely replace ECDSA?

Schnorr signatures will not replace ECDSA. Schnorr signature verification is expected to be implemented with the Taproot soft-fork using SegWit witness version 1. This means only outputs that are locked in v1 SegWit version are expected to produce a valid Schnorr signatures.

ECDSA will continue to be used for spending current non-SegWit and v0 SegWit outputs. All outputs having the OP_CHECKSIG opcode will continue to use the legacy ECDSA signing algorithm and verification.

So, understanding ECDSA is important for understanding the signature verification behind spending all outputs that are not native v1 SegWit. According to P2SH.info only over 2% of all the BTC value locked belong to native SegWit scripts, that too after almost 2 years of implementation. So it can be safely assumed that V1 implementation might not completely replace all current output locking scripts, needing you to understand ECDSA signing algorithm as well if you plan to build products that would accept Bitcoin that require ECDSA signatures to spend.


Is a digital wallet created by blockchain?

The writer of that sentence did a poor job explaining things.

A blockchain (the data structure) does not create a wallet.  It is the data that a wallet uses to determine the state of the money it manages.  It is also the data that new transactions are appended to, thus changing that state, and wallets submit those transactions.

A blockchain does not create a wallet, but wallets do help to create a blockchain.


If you have Zaza and BTC in one wallet it's suggested that you first send your BTCs away (because they're more precious and the BTC client is more trustworthy) then your Zazas so that the Zaza client can't steal your BTC.


What happen with other nodes that does not create a block. In their case, will not they get any reward and also any fees?

They will not get any reward for that block.

  How do they survive?

By finding other blocks. Blocks are mined, on average, every 10 minutes. That means that a miner has a chance to find the next block if they don't find the current one. Blocks are fairly frequent, and the miner who found one block is not necessarily going to find the next one.

  Can the miners choose which transactions validate?

Miners can choose which transactions they want to include a block. They do not get to choose which transactions are valid. It is not the miners' job to dictate what transactions are valid. All transactions that they include in a block must be valid, and they can choose any valid transaction to include.

  If it is like that, all the blocks in that time frame, are they the same?

No, they are not. Miners may choose different transactions. The transactions may be in different order. Miners also have full control over the coinbase transaction which is the first transaction in the block that pays them the block reward. This coinbase transaction can be modified by the miner, and typically is modified in order to have more possible blocks for them to try.

Furthermore, the coibnase transaction for different miners will always be different as they will want to pay themselves, not someone else. Thus the blocks will always be different.


Does ethereum run on the bitcoin blockchain?

Bitcoin and Ethereum have different and unique blockchains. They have no relationship (other than the fact that Ethereum and all other cryptcurrencies based their design on the Bitcoin blockchain).


You can use this simple guide from peercointalk to help you mine on a mac.


Can you provide an example or design document to illustrate where are you stuck?

Spark offers SparkX to create a Bitcoin transaction graph. There is an example on the hadoopcryptoledger web site:
https://github.com/ZuInnoTe/hadoopcryptoledger/wiki/Using-Spark-Scala-Graphx-to-analyze-the-Bitcoin-transaction-graph

best regards


Each block contains the hash of the previous, which is unpredictable. Also, the transactions in each block themselves are unpredictable because one can't tell who is paying who and how much.


Share a common wallet.dat file between two servers

Just wait for the next Bitcoin Core release. They've already implemented -walletdir: https://github.com/bitcoin/bitcoin/commit/0530ba0eae147563921b162ed05347234d8b53c0

https://github.com/bitcoin/bitcoin/pull/11466


What keeps a dominant Bitcoin client vendor with the majority of the market share from unilaterally changing the protocol?

What you are describing there is a client that is a hybrid of Bitcoin and something else.

For instance there is nothing to stop you starting ManishCoin and writing a ManishBitcoinSuperClient. If you can get enough people to believe in ManishCoin then it becomes a useful currency.


CGMiner litecoin mining generates invalid nonce errors

In my experience scrypt mining on GPUs is quite susceptible to cause HW errors and wrong nonces if the parameters are not chosen to match the GPUs the algorithm is run on. As the SCRYPT-README file of cgminer states:

  The reason this is crucial is that too high an intensity can actually
  be disastrous with scrypt because it CAN run out of ram. High
  intensities start writing over the same ram and it is highly dependent
  on the GPU, but they can start actually DECREASING your hashrate, or
  even worse, start producing garbage with HW errors skyrocketing. Note
  that if you do NOT specify an intensity, cgminer uses dynamic mode
  which is designed to minimise the harm to a running desktop and
  performance WILL be poor. The lower limit to intensity with scrypt is
  usually 8 and cgminer will prevent it going too low.

The --benchmark option you specified in your command line tells cgminer to attempt to find an optimal set of parameters, so it will make a few attempts with high intensities as well, which will fail. Once you figured out a good value for the parameters you should be fine.


Why don't bitcoin miners use the padding as extra-nonce?

Changing the padding would result in a completely different digest. Other validating clients do not have access to this "extra nonce" in the padding to validate it, and modifying their clients to implement it would be a hard-fork of the protocol.

The extra-nonce as implemented currently, placed inside the input of the coinbase transaction, was a backward-compatible change which utilized an unused area of the block to place random information. Existing validating clients would still validate the block as valid because the normal process of calculating the merkle root for the block was unchanged.


The format you use depends on how you need to use the private key. Your code produces a raw hex private key, without formatting.

$ node index.js
mnemonic: thunder purchase pave tower lecture upgrade supreme half kid fitness tray shove
addrnodePublicKey: 02ceb48796223dc3777fe210a2034059b5e39b3743e59d62f75ef07a32f8440caf
addernodePrivateKey: 310fe2e677a3ad28acb91d2645bb33882f015ab11e59dce9d2a72905979e3cb6

Raw Private Key

A private key (in bitcoin, i.e. ECDSA SECP256K1) is a 32 byte number between 0x1 and 0xFFFF FFFF FFFF FFFF FFFF FFFF FFFF FFFE BAAE DCE6 AF48 A03B BFD2 5E8C D036 4140.

For example:

0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D

Wallet Input Format (WIF)

However, wallet software typically uses the Wallet Input Format (WIF) to make it easier to copy over. It uses base58check encoding so it avoids ambiguous characters (like 0 and O), it is shorter, and includes a checksum in case of typos. For example:

5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ

WIF Conversion

The process of converting a raw private key to WIF is outline here: https://en.bitcoin.it/wiki/Wallet_import_format:

Take a private key

0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
Add a 0x80 byte in front of it for mainnet addresses or 0xef for testnet addresses. Also add a 0x01 byte at the end if the private key will correspond to a compressed public key

800C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D
Perform SHA-256 hash on the extended key

8147786C4D15106333BF278D71DADAF1079EF2D2440A4DDE37D747DED5403592
Perform SHA-256 hash on result of SHA-256 hash

507A5B8DFED0FC6FE8801743720CEDEC06AA5C6FCA72B07C49964492FB98A714
Take the first 4 bytes of the second SHA-256 hash, this is the checksum

507A5B8D
Add the 4 checksum bytes from point 5 at the end of the extended key from point 2

800C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D507A5B8D
Convert the result from a byte string into a base58 string using Base58Check encoding. This is the Wallet Import Format

5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ

Potential node.js resources:

https://github.com/bitcoinjs/bs58check
https://www.npmjs.com/package/create-hash


He used satoshin@gmx.com (from original Bitcoin whitepaper) and satoshi@vistomail.com (from email logs). gmx.com is a free email service that may or may not have had location based restrictions on registration at the time. vistomail.com is an email service from anonymousspeech, the domain registrar proxy he used to register bitcoin.org.


How can i set fee permanently via paytxfee command

You can do one thing when running bitcoin-cli paytxfee 0.1 command, you can run command to update value of paytxfee inside bitcoind.conf file.

like this:

bitcoin-cli paytxfee NEW_AMOUNT && sed -i 's/paytxfee=OLD_AMOUNT/paytxfee=NEW_AMOUNT/g' ~/.bitcoin/bitcoin.conf

This will set fee for current session also when you restart bitcoin core price will not alter.


If found a broken link on bitcoin.org - who manages the site?

You can make a pull request on their official Github regarding line 400 and 963 from this file: https://github.com/bitcoin-dot-org/bitcoin.org/blob/master/_translations/en.yml

Line 400

  notelicense: "Bitcoin Core is a community-driven https://www.fsf.org/about/what-is-free-software\">free
  software project, released under the http://opensource.org/licenses/mit-license.php\">MIT
  license."

Line 963

  footer: "Released under the http://opensource.org/licenses/mit-license.php\"
  target=\"_blank\">MIT license"

Don't forget other translations as well ! :)

Otherwise, if your are not confortable with Git you can just open a new issue.


I recommend using the services of a user on LocalBitcoins with a high rating and high number of transactions completed.


Difference between account balance and the sum unspent transaction outputs

Accounts have nothing to do with UTXOs.

They are bean counters to help you determine who owns how much, in case you have multiple users sharing the same wallet.

An account is credited whenever a payment arrives to an address associated with that account. It is debited whenever the sendfrom or sendmany RPC is used while specifying that account. If you use any other means of sending, the "" account will be debited.

However, the UTXOs are always shared across all accounts in a wallet, and don't belong to a specific account. When you send out money, all UTXOs are always considered. Accounts can go negative even, if you use the move command (which just increments one account and decrements another).

The above is one of the reasons why the accounts system is deprecated, as it does not match people's expectations. If you want to have actually separated users, with independent UTXOs and balances, you should look at the multi-wallet feature added in 0.15.0.


How can I retrieve the mnemonic words from my bitcoin core wallet?

How most HD wallets work is that they take (or generate) a mnemonic, the mnemonic is used to generate the HD wallet master key, and the master key is used to generate the keys in the wallet. Bitcoin Core doesn't yet support the first part of that: it generates a random master key without using a mnemonic. So there is no mnemonic.

If you would like to get mnemonic phrase, you can generate one here
or using electrum.

Note: electrum mnemonic phrase is not supported everywhere.


What is a bitcoin incoming transaction with value = 0.00000546?

This output value corresponds to the dust limit that is imposed on bitcoin transactions.

Many of these outputs may have been generated as a dust attack to de-anonymize users/ addresses.


Buy bitcoins with my vef (bolivares) in Venezuela without wire transfer

There are no Bitcoin exchanges in Venezuela, and no exchanges that support BTC/VEF.

You might find a trade by putting an offer in on LocalBitcoins, or there might be an offer to sell by someone located near you.

You said you can't do an international wire transfer. A bank wire (in USD, EUR, etc.) to an exhange such as Mt. Gox, BITSTAMP, etc., is not an option for you then apparently.

If you can trade with someone in another country in your region (e.g., Colombia, Peru, Brazil, etc.) there are exchanges in those countries.

Without the use of exchanges, another method of obtaining bitcoins is to offer goods and services with payment in bitcons.  Turismo Surpremo is a business that does this.  You might even be able to buy their excess coins perhaps.

It's possible that working with BitPagos, a payment processor that specifically targets Latin America, might yield a method to acquire coins.


What happens to bitcoin when Segwit2MB activates?

In the event of a chain fork, any Bitcoin that you have now before-the-fork will also exist after the fork on both chains. So if you have 1 BTC now before-the-fork and segwit2x activates causing a chain fork so there is segwit2x chain and non-segwit2x chain, then you will have 1 BTC on the segwit2x chain and 1 BTC on the non-segwit2x chain. However spending your 1 BTC on either chain can result in the 1 BTC on the other chain being spent too since the transaction would be valid on both chains because you are spending a coin from before-the-fork. This is known as transaction replay.


Can an unsynchronized node create a valid transaction?

Node A is holding a chain which is not in sync with the rest of the nodes and node A decides to post a transaction.

Your node, that is not synced, will only let you spend outputs that it has validated as unspent. So in your scenario step 1 may not be able to happen depending on age of the UTXO and what block your node is at. An old node that is not synced can only spend old coins that haven't moved.

A more detailed answer from A. Chow: https://bitcoin.stackexchange.com/a/91822/26873


What is the fastest way to research Bitcoin block chain?

I held a research period on bitcoin (thanks to this project I became fond of Bitcoin) with the release of the alpha software at December, I had to extract information for the construction of an information graph.
I believe in my opinion that there are really many ways to index information but I believe that the fastest ones are to use the same technique that uses bitcoins.

Parser blk files
Deserialize the information in a format of your choice and index it in DB
query the DB and make a read in the appropriate file.

There are two very difficult things

the construction of this indexing system
if you want to access the id wallet you need to build a script decompiler or use the bitcoin node

ps: this is my experience, there can be other ways to build this information, which I don't know (mine is just a three-year thesis, my path has just begun)
This is a good parser for blk, one of the few compatible with Segregated Witness.
The abe project still works but his work times seem unacceptable with the current bitcoin dimension
If you have a big pc, this project is very fast (at least they say so)
Update 2021
The blockchain of Bitcoin grows over time and I think that the result of my work is SpyCBlock can be an efficient solution in terms of memory RAM, I don't know in terms of space.
SpyCBlock offers different deserialization methods like JSON, transactions graph, and a deprecated address graph that use Bitcoin Core to make some work. In addition, a method to deserialize in an efficient way the Bitcoin mempool is under development.
Please note that the software is an academics software, developed by only me, maybe can have some mistake and can be difficult to install all the dependencies, but if it will compile, it should be work fine with the integral bitcoin data.
P.S: The development of BlockSci is stopped in 2020, I don't know why, but I think because it is difficult to scale with the actual dimension of Bitcoin blockchain.


"tx" array inside blocks contains transactions hashes?

Read the fine manual!

  $ ./src/bitcoin-cli help getblock
  getblock "blockhash" ( verbosity )

  If verbosity is 0, returns a string that is serialized, hex-encoded data for block 'hash'.

  If verbosity is 1, returns an Object with information about block .

  If verbosity is 2, returns an Object with information about block  and information about each transaction.

So if you add a 2 to the end of the RPC request, you'll get the full transaction contents rather than just the hash.


How can I view the Blockchain locally on my machine?

You can check the log files , but bitcoind clears it when it starts to get bigger.

although you can read the Bitcoin block file using software/application called Bitcoin Abe
you can parse the data from bitcoin block file to mysql server too.

https://github.com/bitcoin-abe/bitcoin-abe

This software reads the Bitcoin block file, transforms and loads the data into a database, and presents a web interface similar to Bitcoin Block Explorer, http://blockexplorer.com/.

Abe draws inspiration from Bitcoin Block Explorer (BBE) and seeks some level of compatibility with it but uses a completely new implementation.


Clone/download this code from Trezor (don't forget the word list).

Then check your word-list like this:

from mnemonic import Mnemonic

code = "word1 word2 [...] word23 word24"
mnemo = Mnemonic("english")
isValid = mnemo.check(code) # returns a boolean
print('Checksum is valid: ' + str(isValid))


If you had saved "backup" of your wallet in a file with name similar to bitcoin-wallet-backup-YYYY-MM-DD-hh-mm, it can be restored from SAFETY -> RESTORE WALLET on top-right in the app assuming you also remember the associated password for backup file.


If I buy an ASIC miner and run it at home, do I become a Bitcoin node?

Miners and full nodes are different. If you run full node, you add to the already running nodes.
What is the difference between a miner and a full node?
Is a miner running a full node?

It says there are 9741 nodes.

This pie chart shows more than 70k nodes: https://luke.dashjr.org/programs/bitcoin/files/charts/software.html

Related Q&A: How exactly does "CoinDance" determine the current number of public Bitcoin nodes?

Does that mean if I buy an ASIC miner and set it up, then I become a node?

No


What incentive do miners have to respect the Replace-By-Fee flag?

Disrespecting it would require them modifying their software, which has ongoing administrative costs.

Otherwise, there any incentive within the system to behave otherwise. Willfully not taking income maximizing transactions isn't an incentive compatible behavior.


Limits on lightning channels and payments

Stuff like this can usually be found in the lightning-rfc aka BOLT (basics of lightning technologies) which is the formal protocol specification.

Currently channel capacity can't succeed 1/6 of a Bitcoin. However for BOLT1.1 (the next version of the protocol) it was agreed that this limit should be dropped (if both nodes of a channel agree to do so). Single payments should be less than 0.04 BTC. I don't remember if this is also supposed to be changed or even part of the Bolts or if it is just a self imposed limit by the implementations.

Balances can be up to the channel capacity. They are encoded in the commitment transactions which spend the funding transactions. So this part is defined by the bitcoin consensus rules.


It broadcasts blocks and transactions using a logical mesh network, but that shouldn't be confused with physical mesh network proposals.


Transforming existing private key into new private key?

No. A private key corresponds to one public key (and vice versa), and that corresponds to one address (and vice versa). Having a new private key (regardless of where it comes from, so it could be derived from a different private key) would mean that you have a new public key and a new address. Thus you cannot spend any funds associated with the first address with the new private key because it is not associated with that address.


Is there a way to know the type of dogecoin wallet through the receiver address?

This is not possible. Addresses are indistinguishable, and there is no way to determine which wallet generated any address, since the process is wallet agnostic.


Electrum (http://docs.electrum.org/en/latest/index.html) only supports Bitcoin.

There is an Electrum clone (https://electrum-ltc.org/) that supports Litecoin.


What exactly does the "fraud management system" of blockchain checks?

Bitcoin is focused on assuring that the payment is legit.  It doesn't help at all with the payer.

Waiting for confirmations gives you very strong assurance that the payment is genuine and final, and that neither the payer nor any outside authority can do anything to reverse it.  The money is yours, full stop.  There are no chargebacks.

However, you don't get any verification of the payer's identity.  There are no names attached to Bitcoins, only addresses which are effectively anonymous.  (Theoretically there are ways one can try to trace a Bitcoin address back to the person who holds it, but it's unlikely that you'll want to devote the necessary time and resources, and you chances of success are still pretty slim.)

So if someone pays you in Bitcoin for an account which they then use to spam, you can cancel their account and keep their money, but you have basically no other recourse.  You probably won't be able to find them to send nasty letters or pursue legal action or call the police.

Of course, along the lines of "keep their money", you could require Bitcoin customers to put down a large deposit, which you keep if they abuse your system.  However, this could discourage legitimate customers, who now just have to trust that you will return their deposit as promised if they behave; by the same token as above, they have very little recourse if you don't.


Why is there so much uncertainty with SegWit2x when it has 85%+ mining support?

The problem is that this will most likely result in a hard fork.

There is no well tested core client which supports segwit2x. The bitcoin core developers oppose that. Confusingly, their proposal (just called segwit) announces a soft-fork which is designed to be compatible.

In the end, this is a political game. Miners tend to support segwit2x, while bitcoin core developers support UASF. Their statement about the danger of a chain fork can be found here: https://bitcoin.org/en/alert/2017-07-12-potential-split


Check your internet connection, make sure your mining device connected right, restart your devices.


Why would you pay a trading fee for Ripples?

For the same reason you'd choose one exchange over another (in general) even if the other has lower fees. Examples of reasons not related to trading fees for which one might prefer a particular exchange:

Higher volume/liquidity
Better ergonomics
Faster trade execution
Easier deposits/withdrawals (especially when fiat is concerned)
More trading pairs
More reliable


Currently I'm in the process of finishing my master thesis on the topic of Bitcoin security, and I know there is one more person making a similar master thesis. While it might not be as in-depth of an analysis as a professional cryptography expert might perform, it should be fairly extensive.

Over the course of working on the subject I haven't found any article more comprehensive than the Bitcoin wiki page on Weaknesses of Bitcoin. A lot of problems have been covered in depth on this Stackexchange, as well as some topics on the Bitcoin forum.

EDIT:

My master thesis is available to read in this thread on the Bitcoin forum. It covers a wide analysis of many aspects of Bitcoin, from its cryptography algorithms, through the protocol, the standard client, Bitcoin-related applications, and even users' behaviours. I hope that answers your question better.


is it currently possible in the Bitcoin blockchain to send coins to an address only after two parties sign messages signaling the funds to be released

It's a built-in blockchain feature called a multisig transaction.

https://en.bitcoin.it/wiki/BIP_0010


Flaw in Bitcoin protocol regarding incentives to share transactions

This is a non-issue.  The Microsoft paper did not appear in a peer-reviewed venue (journal or conference).

There are (at least) two parts to the bitcoin network: the peer-to-peer transaction broadcasting network and the miners.  Only the miners have a disincentive to propagate transactions.  The overwhelming majority of the nodes on the internet running bitcoind are not mining or else are doing trivial amounts of CPU-mining because their admin forgot to use the -gen=0 flag.

If so-called "CPU-friendly" cryptocurrencies like "Tenberix" achieve their goals (which is doubtful) they may be vulnerable to this problem since they are intended to avoid the sort of specialized-miner situation that bitcoin embraces.


What is the largest transaction by value to date for bitcoin currency?

Probably this one, 550,000 BTC transferred at one time.

http://blockexplorer.com/tx/29a3efd3ef04f9153d47a990bd7b048a4b2d213daaa5fb8ed670fb85f13bdbcf

Now the question, was it a transfer from one person to another, or was it a transfer simply to, for example, another wallet once the passphrase encryption feature was made available.


I bought a droplet on DigitalOcean running Ubuntu 12.04. It is only $5/month. I opened the port, compiled my *coind program on it, created my .conf file and ran it. Now my client coin programs connect to it.


How to convert Script hash into opcodes, in Ruby?

I guess I found an answer:

script = Bitcoin::Script.new([hash].pack('H*'))


Testvectors for dedicated hardware miner

The block headers in the blockchain are your test vectors, they already contain the appropriate nonce. Midstate can be computed from these headers, mining software does such a midstate computation (so crib this bit from their source code).


BIP 32 seed resulting in an invalid private key

Sounds like a cool project!

  Given a random seed, you apply HMAC-SHA512 to get the master extended private key. In it, there is a private key, which can be invalid if equal to 0x0000000000000000000000000000000000000000000000000000000000000000 or greater than 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140.

That's mostly right. It should error if I_L is greater than the curve order, (that's the number you have there) or if the child key (k_i) is 0. (https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#private-parent-key--private-child-key)

  Have you guys seen any seed which generates an invalid private key? I looked through the internet for such known value and could not find it.

It would be really surprising if someone knew a seed that would do that. The two conditions happen about 1 in every 2^127 times, and about 1 in every 2^256 times, respectively. If SHA512 is a secure hash function, it should take about 2^127 runs of it to find a seed that fails.

To be clear, such a seed exists, but we don't know what it is.

While researching this, I found this error message in the pycoin library. It shows up if either of the conditions you mentioned happen.

_SUBKEY_VALIDATION_LOG_ERR_FMT = """
BUY A LOTTO TICKET RIGHT NOW! (And consider giving up your wallet to
science!)

You have stumbled across an astronomically unlikely scenario. Your HD
wallet contains an invalid subkey. Having access to this information would
be incredibly valuable to the Bitcoin development community.

If you are inclined to help, please make sure to back up this wallet (or
any outputted information) onto a USB drive and e-mail "Richard Kiss"
<him@richardkiss.com> or "Matt Bogosian" <mtb19@columbia.edu> for
instructions on how best to donate it without losing your bitcoins.

WARNING: DO NOT SEND ANY WALLET INFORMATION UNLESS YOU WANT TO LOSE ALL
THE BITCOINS IT CONTAINS.
""".strip()

Sound advice. Winning the lottery is a mere 1 in 2^28 chance.


Is there a way to verify how many Liquid Bitcoins are in existence?

You can easily verify the liquid circulation, in fact any liquid node can do this in realtime as part of its operation if you run a Bitcoin node along side it.

Pegins can't, however, be reconized until after they're claimed on the sidechain.  Before then the addresses are cryptographically indistinguishable from other similar multisig transactions on Bitcoin. But when they are released into the sidechain the party that generated the address publishes the information needed for everyone to find them.

https://liquid.horse/ is a website that runs a liquid node and reports this sort of data.


Create a raw transaction and broadcast it to blockchain using bitcoin core

EDIT: based on OPs request, I put examples in here:

there are a lot of examples for different tx types on bitcoin.org, in the developer examples. Basically you will need three steps. Assuming you are on OpenBSD/MacOS/Linux, you can go this way:

1.) createrawtransaction - this is what you have already, and it looks ok. I don't know if the previous tx ID or v_out is correct, assuming you know the details, your string is ok (otherwise check with "bitcoin-cli -regtest listunspent", and adopt TX_ID and V_OUT accordingly). I also assume, that the address is one which is in your wallet. Otherwise you might just create an address, and proceed afterwards like this:

UTXO_TXID=dbdc2e2c7f143af70c5e7e8725f55d226b3c058d7bf34a303
UTXO_VOUT=1
NEW_ADDRESS=n3xYQtxvVwpBPSbgGsGRdMWz1YTUjakiMV
bitcoin-cli -regtest createrawtransaction '''
    [
      {
        "txid": "'$UTXO_TXID'",
        "vout": '$UTXO_VOUT'
      }
    ]
    ''' '''
    {
      "'$NEW_ADDRESS'": 1
    }'''

you provide this returned hex string to another variable:

RAW_TX=01000...

2.) signrawtransaction - the previous command returns a hex string, that you will use to sign the transaction - again, see the docs. First I verify my created tx, and then sign:

bitcoin-cli -regtest decoderawtransaction $RAW_TX
bitcoin-cli -regtest signrawtransaction $RAW_TX

again you assign the result to a variable:

SIGNED_RAW_TX=01000...

3.) sendrawtransaction - again you take the hexstring of the previous command as parameter, and/or see the docs.

bitcoin-cli -regtest sendrawtransaction $SIGNED_RAW_TX

and maybe a verification as step 4:

bitcoin-cli -regtest generate 1

this generates a block, and you can see on the $NEW_ADDRESS, if funds have been transferred.

I just entered the two keywords here in the search function, and also found a lot of answers.


How to generate a bulk wallet offline with python, java or c++?

A very simple way is to use Vanitygen with the following command:

vanitygen -k -o output.txt -s seeds.txt 1

-k keeps it going after it finds a hit
-o output.txt will write the key pairs to the file output.txt
-s seeds.txt will let you have different seeds. Create this on beforehand
1 is the pattern Vanitygen will look for. Because all addresses start with 1, every hit will be good. Also nice if you want to have nice addresses, like 1Hristo or something. Keep in mind that it will reduce speed ALOT.

Vanitygen creates about 300 kKey/second on my 2010 MBP CPU. With oclvanitygen it is around 750 kKeys/second. The output.txt will reduce the speed a bit, but it will not take a lifetime. I am not on a computer right now on which I can test the command, but it should work.

This will generate key pairs until infinity. If you really want to have exactly 1000000 (or any other number) pairs, try something with a bash for-loop, and something like

vanitygen 1 >> output.txt

Again, I cannot check this right now, so I don't know how the pairs will be in the output.txt, but it should be appended and readable for you.


How is the hash that is signed calculated?

scriptSig contians a signature of the concantenation* of the previous transaction's script and the new transaction.  It has to be both because if it were a signature of just the previous transaction, someone could swap the output address in the new transaction and relay the transaction sending the coins to himself!

scriptSig also contains the public key to verify the signature because the previous transaction only has the hash of the public key.  The hash of a public key is an address.

Source: https://en.bitcoin.it/w/images/en/7/70/Bitcoin_OpCheckSig_InDetail.png

* Not really concatenated, it's inserted in the middle.


Which Wallet clients support a universal export .wallet file?

There are a few different types of files which all contain the same basic information, an encrypted copy of private keys. In short there is no universal format yet.

The satoshi client uses a wallet.dat file, but as far as I know only
armory supports that format.
Blockchain.info and use uses an encrypted json file (wallet.aes.json)
Multibit uses a .wallet format which I believe is unencrypted.
Multibit also has the ability to import encrypted json files for
private keys (i.e. from Blockhain's backups)
Electrum uses a   .electrum file, but you can import and dump private    keys using
command line functionality.

It would seem that the easiest and most universal format for now would be an aes encrypted json file for exporting private keys.


Does a logical mining pool assign harder and harder difficulty to the same miner?

[Edit: my previous answer was incorrect in it's explanation, I've updated it since]

  would the next logical thing for the pool to be to assign that miner a slightly harder bit of work to do?

No. In a simple sense, consider this: if the difficulty is increased every time a miner submits their share, then it will increase endlessly over time, which is obviously undesirable.

  If the pool does not assign harder work and lets the miner continue to solve problems at the same difficulty (which is less than the network difficulty), how does the overall pool benefit?

Miners in the pool will split the rewards for valid blocks amongst themselves, according to the share of hashpower each miner is contributing. The pool difficulty is a way to track each miner's share, while also dividing up the work load amongst pool participants.

Each miner has a certain amount of hashpower available, and will set their difficulty to an appropriate level so that they can submit their work and claim their share of the rewards. Setting the difficulty too low is not a way for a miner to claim an unfair share of the rewards, it just means they'll likely find a valid hash sooner, but that valid hash will be worth a smaller share, which balances things out.


In a multi-sig transaction, if one party refuses to sign, what happens to coins?

Only valid transactions transfer control of balances. Since the transaction was never completed, the balances remain under control of the original owners.


How to create a transaction input from tx id of UTXO?

TxInput is a class used in this example to define the input used for creating a transaction.
You can download and install Atom Editor.
Install script package to run python code in atom.
Download and Install Python.
Install bitcoin-utils library: $ pip install bitcoin-utils


What will happen to our existing BTC? Can we still use those? Will those be of no use?

At this point it seems likely to me that the BTC chain will survive a hard forking attempt by BTU. Really, except for an impressive hash rate it seems to have almost no other support.

  Will the price of BTC rise or fall?

Both. Probably not at the same time. Who knows really.

  Will the price of BTU be same as BTC?

No. Most likely they will be freely traded against each other.

  Can we convert BTC into BTU?

After the split, the same coins will exist on both chains at first. After disintermediating them, you should be able to sell one for the other, if both have sufficient buyers to maintain any sort of price greater than zero.


Multibit security — How anonymous is it?

I think what you are asking is this:

Because Multibit is a lightweight SPV wallet, it uses Bloom filters to request the status of its own wallets from other peers rather than collecting the latest blocks.

Could those other peers, who already know the IP address, conclude that the request for information concerning certain addresses imply that this IP address is looking after these addresses?

The answer would be yes it could conclude this, but it could never say for sure if the private keys were also owned at that IP address it could only assume this.

The matter is further complicated because connection to peers is fairly random according to their availability.

EDIT I am updating my reply, as it appears that some research has been carried out which may contradict what was thought to be the case, but this is not strictly related to Multibit, but all wallets that use internet protocol. The Coindesk article points to the paper:

"Eavesdropping" attack


How do I fully uninstall the Bitcoin Wallet app for Android?

The size of the blockchain download by BW has significantly reduced recently, and is only headers at best so you're only looking for a 20-40Mb file not gigabytes.

You should be able to locate the private keys here:

/data/data/de.schildbach.wallet/files

If you need assistance with accessing your rooted phone (you probably don't) I wrote an article detailing Bitcoin recovery operations on Android that may provide useful supporting information.


Can multiple wallets send 1 transaction for the combined balance?

If you are using a wallet which supports importing private keys, such an Bitcoin Core, you can just import the private key of your other wallet: https://bitcoin.stackexchange.com/a/5944/14325


For each new block to be fixed to the end of the blockchain, a mathematical puzzle must be solved. In simple terms, the block is hashed, along with a hash of the previous block and a 'nonce', to create a new hash. The nonce can be thought of as the 'solution' to the block. It is a value such that, when all the information (previous hash, transactions and nonce) are hashed together, the resulting hash is below a certain value. (You can see that all the hashes of blocks have a long string of leading zeroes.)

The aim is for a new block to be completed every ~10 minutes, so the network agrees on a 'hash threshold'. The more computers that are competing to find the nonce, the lower the threshold becomes. How many computers are competing is gauged by whether blocks are regularly found in less than, or greater than, ten minutes on average.

So if your Bitcoin client finds a long blockchain, where each nonce is found according to a low threshold, it can surmise that a lot of work has gone in to creating that blockchain.

Even if another blockchain of the same length existed, for it to have such 'rare' hashes a lot of computer time would need to be dedicated to its construction. The longer the (real) blockchain gets, the harder it is to construct one that is equally long and has equally low hashes for each block.


How could I make my own API to query the blockchain

You could use www.tatum.io to do all of that. We provide blockchain infrastructure and a simple, unified REST API that supports over 20 blockchains. You can do everything with a free plan, and upgrade to a paid plan when you need more that 5 API requests per second.


Why use OP_RETURN for long-term timestamping if they are pruneable?

The point of timestamping is not data storage (that's a different use case). Timestamping is being able to prove that a particular piece of data existed before some point in time.

If you create a transaction that commits to a particular (hash of a) piece of data, you can always prove its presence in the blockchain by keeping the blockchain (including the block with your transaction) yourself.

In fact, that's not even necessary. Due to the fact that Bitcoin transactions are organized in a Merkle tree in blocks, you can just keep the transaction, and the hashes in the Merkle tree that connect your transaction hash to the Merkle root of that block. Anyone who has validated the chain (and thus has at least the block headers) can verify that implies your transaction was part of the chain.


When did Satoshi Nakamoto release Bitcoin v.0.1 to the public? 08 Jan 09 or 09 Jan 09?

It depends on how you define release.

Satoshi sent the email to the Cryptography mailing list on Jan 8 2009 UTC. However because the Cryptography mailing list is moderated, that email did not reach email subscribers until Jan 9 or 10 2009 (it's actually Jan 10 2009 at 1 AM UTC).

The discrepancy you see is that many people refer to The Mail Archive source. The Mail Archive is a subscriber to mailing lists and publishes the emails it receives. So it received the email on Jan 9 in its local time. The metzdowd.com source is "more accurate" because that's where the list is actually hosted, so it shows the time that the mailing list server received the email.

Presumably the link the Satoshi provides was reachable at or before he sent the email, so you could say that Bitcoin was actually released on Jan 8.


Bitcoin-cli -regtest getaccount, listaccounts, setaccount, method not found

accounts method was deprecated in v0.17 and was removed since v0.18. accounts was replaced by label and it provides more flexibility as compared to before such as setting label on any address, not just receiving address. It also irons out issues raised in the past. If you are used to using accounts to mimic separate wallets, you now have an option to use separate wallets in separate wallet files in Bitcoin Core.

So according to the commands you are looking, you will replace them by:

getaccount with getaddressinfo
listaccounts with listlabels
setaccount with setlabel

You can see the full documentation of accounts vs labels in the v0.17 release docs.


Is the block 'chain' actually a merkle tree?

Each block contains a merkle tree of new transactions and the hash of the previous block. New transactions can consume the outputs of previous transactions and create new unspent outputs for future transactions.

Bitcoin currently does not maintain any kind of universal or canonical tree of all unspent outputs. Individual nodes are free to maintain a database of UTXOs (unspent transaction outputs) using any method they prefer.

The blocks do literally form a chain since each block contains the hash of the previous block.

Ripple works in a somewhat simpler way. There are accounts with balances that are arranged in a Merkle tree. Each ledger contains the hash of the previous ledger, a Merkle tree of transactions and the deltas to the state each transaction created, and the hash of the new Merkle tree of system state.


How does the full lifecycle of a cryptocurrency trading look like?

Depending on where you live there are different options. I would suggest, if in the US, to go with one of the larger platforms like Kraken.com, or CoinBase.com. In these systems you can wire funds (Kraken) or attach to a bank account to purchase currency.

In my experience, CoinBase will be your training wheels. It's hard to see what you're buying/selling as the actual transaction occurs automatically when you click the button. What you see is not what you'll get (unless that changed in the last week). However it is very easy to use.

Kraken will require more verification for additional tiers (work with more value). But you can control the trading. You can set buy/sell limits which means you won't get 1 penny less than what you told it. They have tons of additional trading options if you want to get more advanced as well.

Final note, Kraken supports many more crypto currency options and bought cryptowat.ch over a year ago for a nice live feed of prices across multiple platforms.

Hope this helps you get started!

Edit: I'm not here to judge intentions or viability. The question was  "what can i use". Any assumption (including commentary on the current market, political, legal, etc) other than "I'm simply answering the question" would be incorrect.