Can two crypto currencies have the same name?

What keeps coins distinguished is primarily the protocol and secondarily the genesis block.

If someone tries to copy bitcoin exactly using the exact same source only with a different name, all of the users will simply be part of the bitcoin blockchain.

If someone tries to use the same protocol but with a different genesis block then a new bitcoin ripoff has begun.

If someone tries to use the same genesis but with a different source code, the results will depend on the protocol, but most likely it will simply be a fork.

All of the 1st generation alts use variations on the bitcoin source code and have new genesis blocks.

A new protocol and a new genesis block are the best ways to ensure a new coin.


Is there any python lib could be used to analysis the local block data?

https://github.com/keviny/bitcoin-block-parser
May could help for simple analysis


Why wipe all BTC from an imported address?

Once your import the key, the key now exists in two places: your paper and your wallet.  Because of this, you've lost the advantage that a paper wallet has for cold storage.  What you now have is a paper backup of one of the keys stored in your hot wallet.  Any risks of a hot wallet now also apply to your paper wallet.

In addition, there is the inherent privacy issues with re-using a Bitcoin address, regardless of how that wallet is stored.  There aren't many advantages to re-using addresses, and this case is no exception.  If you still need a paper wallet after importing one, you should really create a new one.


the ppa for ubuntu is https://launchpad.net/~bitcoin/+archive/ubuntu/bitcoin it shows the support of ubuntu 0.13.1

so you need to run

sudo add-apt-repository ppa:bitcoin/bitcoin
sudo apt-get update

otherwise you can compile from source


Why would I trust a cryptocurrency that allow only 3 transactions/s?

You are equating the value of a currency with the performance of just one way to exchange that currency. There are poor ways to exchange dollars as well.

Also, I'm not sure what you mean by "invest in such service". You can invest in bitcoin-related businesses and you can invest in bitcoin, the currency. But I don't see how you can invest in the bitcoin generation and transfer service provided by the blockchain.


How do I backup my wallet with bitcoin-cli over RPC?

The process writing the file is bitcoind, not bitcoin-cli, which is simply issuing RPC commands to the server.bitcoind needs to be able to write to the destination, which can’t be another users home folders unless you explicitly give it permission.


Different candle positions in coins with same OCHL values

Keep in mind exchange data might not be reliable in all instances due to the way they have it implemented. Your best bet is to see if the exchange can provide a data field of historic prices and then plot it yourself using excel.


Confused About Hash In Satoshi Nakamoto Diagram

Firstly, transactions are not blocks, and blocks are not transactions. They are two distinct data structures that you seem to think are the same thing.

  How is that calculated?

By performing SHA256 double on the transaction.

  I see an arrow coming from the left (I'll get to that in a moment)--it seems to depict the Hash of the previous transaction block. But the arrow coming from Owner 1's Public Key confuses me too. Is this diagram saying that owner 1's public key is hashed together with the previous block's hash value? Is that what actually happens in Bitcoin, or is there more detail?

Yes, the public key is part of the data that is hashed in a transaction.

  'd like to see the original block in the depicted hash chain because that original block wouldn't have a previous block hash to reference. So would that mean that the first block's hash is just a hash of the owner's public key?

A transaction is more than just a public key and an output. But the first transaction in that transaction chain does not have any inputs so it does not have any previous transactions that it references. This transaction is known as a coinbase transaction or a coin generation transaction. It is created by miners and essentially produces Bitcoin out of nothingness.

  Are there any good resources that go into more technical detail about the first block in the transaction hash chain and how these hashes are calculated?

Bitcoin.org's developer guide explains most of Bitcoin's details.

  Is the arrow coming from the Owner's Public Key saying that the Hash is encrypted with the owner's public key?

No, it is saying that the public key is used to verify Owner 1's signature. This public key is specified in the previous transaction. In order to know what the previous transaction is, we place the hash of it in the current transaction (Owner 2's transaction). That way we can quickly lookup Owner 1's transaction to retrieve Owner 1's public key.

There is no encryption that happens in the Bitcoin protocol. Nothing is encrypted.

  In other words, does the previous transaction's hash get somehow combined with a new hash before being encrypted with the public key?

Yes, the previous transaction's hash is combined with the other data in the current transaction to produce the current transaction's hash.

Instead of trying to understand the technical details and diagrams that Satoshi put in the whitepaper, you should try to understand how Bitcoin actually works today based on the code and other documentation available. The whitepaper does not describe how Bitcoin actually works; it was written months before the first release and lots of details changed between the concepts in the whitepaper and the actual implementation of those concepts.


How do I use CHECKLOCKTIMEVERIFY to prevent a transaction being spent before 100 blocks?

Yes, you can use OP_CHECKLOCKTIMEVERIFY to make a transaction output unspendable for a certain number of blocks.  However, you can't use it directly in an if-else block as you have described.  When OP_CHECKLOCKTIMEVERIFY executes, it doesn't place a result value on the stack.  It either throws an error (invalidating the transaction attempting to spend the output), or continues executing as if nothing happened.

To create a transaction as you describe, you will need to use multisig, such that one party can spend the transaction as soon as the correct number is provided (input to a hash function, I presume?), OR you can spend it back to yourself after the lock time expires.  This is basically how the lightning network works.  You should check out Lightning Networks Part II: Hashed Timelock Contracts (HTLCs)


How to use Bitcoin Core's submitblock method


If a block chain is considered invalid, how about transactions in this block chain?

Any transactions in a block that is no longer part of the longest chain will revert to unconfirmed (assuming they're not in the new longest chain) and return to the mempool. In most cases, assuming the transactions remain valid (i.e. the outputs they spend aren't already spent in the new longest chain), said transactions will simply be mined into a new block on the longest chain.


How to Pay to Multisig Wallet Using python-bitcoinrpc?

I came up with a script to pay to, and spend from, a multisig wallet.

Here are the steps I was missing before:

madd1 = msig1["address"]
a1 = w0_rpc.getaddressinfo(madd1)
scriptPubKey1 = a1["scriptPubKey"]
pubkey1 = hex_str_to_bytes(scriptPubKey1)
tx1.vout.append(CTxOut(int(8 * COIN), pubkey1))

Below is the full script.

#!/usr/bin/env python3

import pprint

from test_framework.test_framework import BitcoinTestFramework
from test_framework.messages import CTransaction, CTxIn, CTxOut, COutPoint, ToHex, COIN, sha256
from test_framework.script import CScript, CScriptOp, OP_1, OP_DROP, OP_2, OP_3, OP_HASH160, OP_EQUAL, hash160, OP_TRUE, OP_DUP, OP_EQUALVERIFY, OP_CHECKSIG, OP_CHECKMULTISIG
from test_framework.util import hex_str_to_bytes, bytes_to_hex_str
from test_framework.address import byte_to_base58

class RawTxTest(BitcoinTestFramework):

    def set_test_params(self):
        self.num_nodes = 2
        self.extra_args = [[],["-txindex"]]

    def run_test(self):
        """Main test logic"""

        self.log.info(f"\n    DEBUG START")

        # initialize node variables
        n0 = self.nodes[0] # This node used for initial balance
        n1 = self.nodes[1] # All test wallets created on this node

        # TRANSACTION #0 - pay from node 0 to addr0
        w0 = n1.createwallet(wallet_name="wallet0")
        w0_rpc = n1.get_wallet_rpc('wallet0')
        addr0 = w0_rpc.getnewaddress()
        self.log.info(f"\n    DEBUG addr0={addr0}")

        txid0 = n0.sendtoaddress(addr0, 10.0)
        n0.generate(6)
        self.sync_all()

        # dump the tx to the log
        raw_tx0 = w0_rpc.getrawtransaction(txid0, True)
        s = pprint.pformat(raw_tx0)
        self.log.info(f"\n    DEBUG tx0={s}")

        # write the balance to the log
        bal0 = w0_rpc.getbalance()
        self.log.info(f"\n    DEBUG bal0={bal0:f}")

        # TRANSACTION #1 - Pay from addr0 to multisig
        NUM_SIGS = 2 # M
        NUM_KEYS = 3 # N
        add1 = [w0_rpc.getnewaddress() for _ in range(NUM_KEYS)]
        pub1 = [w0_rpc.getaddressinfo(a)["pubkey"] for a in add1]
        priv1 = [w0_rpc.dumpprivkey(a) for a in add1]
        msig1 = w0_rpc.createmultisig(NUM_KEYS, pub1, "bech32")
        self.log.info(f"\n    DEBUG msig1={msig1}")
        madd1 = msig1["address"]
        redeemScript = msig1["redeemScript"]
        self.log.info(f"\n    DEBUG madd1={madd1}")

        tx1 = CTransaction()
        vout = [v["n"] for v in raw_tx0["vout"] if addr0 in v["scriptPubKey"].get("addresses", [])]
        assert len(vout) == 1
        v = vout[0]
        tx1.vin.append(CTxIn(COutPoint(int(txid0, 16), v)))
        a1 = w0_rpc.getaddressinfo(madd1)
        self.log.info(f"\n    DEBUG a1={a1}")
        scriptPubKey1 = a1["scriptPubKey"]
        pubkey1 = hex_str_to_bytes(scriptPubKey1)
        tx1.vout.append(CTxOut(int(8 * COIN), pubkey1))

        priv0 = w0_rpc.dumpprivkey(addr0)
        tx1 = w0_rpc.signrawtransactionwithkey(ToHex(tx1), [priv0])["hex"]
        txid1 = n0.sendrawtransaction(tx1, True)
        n0.generate(6)
        self.sync_all()

        # dump the tx to the log
        raw_tx1 = w0_rpc.getrawtransaction(txid1, True)
        s = pprint.pformat(raw_tx1)
        self.log.info(f"\n    DEBUG tx1={s}")

        # write the balance to the log
        bal1 = w0_rpc.getbalance()
        self.log.info(f"\n    DEBUG bal1={bal1:f}")

        # TRANSACTION #2 - Pay from multisig to addr2
        addr2 = w0_rpc.getnewaddress()
        self.log.info(f"\n    DEBUG addr2={addr2}")
        a2 = w0_rpc.getaddressinfo(addr2)
        pubkey2 = hex_str_to_bytes(a2['pubkey'])
        p2pk2 = CScript([pubkey2, OP_CHECKSIG])
        tx2 = CTransaction()
        tx2.vin.append(CTxIn(COutPoint(int(txid1, 16), 0)))
        tx2.vout.append(CTxOut(int(7 * COIN), p2pk2))
        scriptPubKey = raw_tx1["vout"][0]["scriptPubKey"]["hex"]
        amount = raw_tx1["vout"][0]["value"]
        prevtxs = [{"txid": txid1, "vout": 0, "scriptPubKey": scriptPubKey, "redeemScript": redeemScript, "amount": amount}]

        tx2 = w0_rpc.signrawtransactionwithkey(ToHex(tx2), priv1, prevtxs)["hex"]
        txid2 = n0.sendrawtransaction(tx2, True)
        n0.generate(6)
        self.sync_all()

        # dump the tx to the log
        raw_tx2 = w0_rpc.getrawtransaction(txid2, True)
        s = pprint.pformat(raw_tx2)
        self.log.info(f"\n    DEBUG tx2={s}")

        # write the balance to the log
        bal2 = w0_rpc.getbalance()
        self.log.info(f"\n    DEBUG bal2={bal2:f}")

        self.log.info(f"\n    DEBUG END")

if __name__ == '__main__':
    RawTxTest().main()


What is the best way to exchange MTGUSD to USD?

You can sell MTGUSD directly at bitcoin-otc or at bitcointalk. If you deal with reputable members, the risk of a receiving a chargeback is minimal.
Note that you don't need to register at bitcoin-otc to do this. Just drop by the channel and announce that you are selling.

Bitinstant used to have paypal withdrawals, but they aren't working at the moment.


What is the "silk road" and what does it have to do with bitcoin?

Silkroad is an anonymous online marketplace inside the Tor network which became famous for selling illegal drugs.

They don't have anything to do with the Bitcoin project, except for the fact that they accept bitcoins as a payment method.


Sent a 1079 byte transaction without a fee on accident

Bitcoin-Qt will insist you add a fee if (and only if) it's required to get confirmed ever - so it should confirm eventually. If you want to always include a fee for a faster confirmation, go into Settings. Unfortunately, while Bitcoin allows you to add a fee later, Bitcoin-Qt does not support this.


Inflation is "a general increase in prices and fall in the purchasing value of money."

One cause of inflation is printing more money.

By halving the rate of production of new money you halve its inflationary effect.


Yes, when you use an online wallet service, you are trusting the website operator to generate and maintain your private key(s) for your account.

There is a saying that goes something like, "Unless you hold your own private keys, your bitcoins aren't really yours."


Recovering a HD wallet from a partial seed phrase

(The language used in this post is Python)

Breadwallet uses BIP39 to generate the 128-bit master seed from the 12-word mnemonic. The master seed is then used to generate a set of wallets/accounts containing chains of addresses, using BIP32.

First off, import hashlib and binascii, we're going to need them later.

import hashlib
from binascii import hexlify, unhexlify

Lets assume you have 11 of the 12 words in your seed phrase. For simplicity's sake, I'll use the first 11 words in the BIP39 wordlist:

partial_seed_phrase = [ 'abandon', 'ability', 'able', 'about', 'above', 'absent', 'absorb', 'abstract', 'absurd', 'abuse', 'access' ]

The wordlist contains 2048 entries, which gives each word 11 bits of entropy (211 = 2048). The 12 words have 12*11 = 132 bits of entropy in total. The HD master seed is 128 bits in length, and there's a 4-bit checksum attached to the end, which brings the total bits up to 132. So far so good.

If we assume that the wordlist is a 2048-element list (omitted due to space constraints), we can find the index (in decimal) of the elements in partial_seed_phrase:

mnemonic_in_decimal = map(wordlist.index, partial_seed_phrase)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Let's convert mnemonic_in_decimal into an array of 11-bit wide binary numbers.

mnemonic_in_binary = map('{0:011b}'.format, mnemonic_in_decimal)
# ['00000000000', '00000000001', '00000000010', '00000000011', '00000000100', '00000000101', '00000000110', '00000000111', '00000001000', '00000001001', '00000001010']

We know that a single word (11 bits) is missing from some unknown location in this array. In non-ideal circumstances, we would have to check each of the 12 locations for the missing word against 2048 possible words each, for a total of 24576 (12*2048 = 24576) potential master seeds.

for missing_word_position in range(0,12):
    # The missing word belongs at some index from 0-11 in the final 12-word phrase

    for wordlist_index in range(0, 2048):
        # Iterate over all possibilities for the missing word

        missing_word_binary = '{0:011b}'.format(wordlist_index)
        front_half          = ''.join(mnemonic_in_binary[0:missing_word_position])
        back_half           = ''.join(mnemonic_in_binary[missing_word_position:12])
        seed_and_checksum   = front_half + missing_word_binary + back_half

        seed     = seed_and_checksum[0:128]
        checksum = seed_and_checksum[-4:]

Thankfully, we have a 4-bit checksum, which means only one in every 16 seeds (24 = 16) will be valid. This means we will end up with a final total of approximately 1536 master seeds (24576/16 = 1536) to check for funds. The checksum is derived from the first bits (in this case, 4) returned by applying the SHA-256 hash function to the seed, so the final number of valid master seeds can vary, but will average out at around 1/16th of the total possible seeds.

[ More to come later, if anyone wants to help write descriptions or code for any of the following steps, I would appreciate it! ]

To do:

Calculate the actual_checksum from the first 4 bits of sha256(seed)
compare checksum to actual_checksum. If they are equal, push the seed into an array of valid master seeds.
Calculate the master node, which is HMAC-SHA512(seed)
Calculate an account from the master node
Calculate a wallet chain from the account
Calculate the first 5 private keys in the wallet chain
Calculate the first 5 public keys from those private keys
Write up a description and steps for recovering partial phrases for BIP44 wallets
Write a program to query either a blockchain locally, or a blockchain explorer API online. Pass it the combined list of generated public keys, and see if any have a balance.


Yes, this is related to GPU mining. From cgminer's README:

  INTENSITY INFORMATION:

  Intensity correlates with the size of work being submitted at any one
  time to a GPU. The higher the number the larger the size of work.
  Generally speaking finding an optimal value rather than the highest
  value is the correct approach as hash rate rises up to a point with
  higher intensities but above that, the device may be very slow to
  return responses, or produce errors.

I would just leave it set to 'dynamic,' or --intensity d . That will adjust it automatically depending on how long it takes to complete work.
(nitty-gritty details)


Is the 51% attack the only technical reason no country will adopt Bitcoin as a state currency?

If what you mean by adopt bitcoin as a state currency means replace their existing fiat currency; I believe there would a lot bigger problems to consider. If they did do that, it would essentially be saying that their money no longer has any value, which would cause a massive panic within their population. A type of panic similar to when India banned the 500 and 1000 Rupee notes.

You'd also have to consider countries that have that type of GDP, they would need the infrastructure for everyone to be able to be connected to the internet and have devices to use Bitcoin. Also they would need everyone to be tech savy enough to understand how to use bitcoin.

Also, with the lightning network at its current state, bitcoin transactions can't scale to an entire countries' economic activity.

So I would say that a 51% attack is pretty low concern for a country looking to adopt bitcoin as a state currency. A better approach would probably be to start stock piling bitcoin and perhaps even use it to back their fiat currency to strengthen it.


Actually, a bitcoin miner is only concerned with creating the next block on the blockchain, through a computationally-difficult problem. It is the role of bitcoin nodes to verify this proof-of-work as they receive these newly created blocks.

As reference, see https://en.bitcoin.it/wiki/Mining


Combine multiple Bitcoin balances into a new wallet?

You can use new address for each transaction and receive BTC in the same wallet.
Use one of the open source bitcoin wallets.


Which price need to be taken for bitcoin analysis

I worked in IT in the traditional finance industry for a while many moons ago.

There is no 'right' answer to what you want. What's important is not that you use one or other, but that you are consistent and reasonable in your choice. Being consistent example: if you use the open price, always use the open price. Being reasonable example: if you are analysing for highs, then use the highs that come in.

Bitcoin is a 24 hour market unlike traditional trading where they will often use the close. There, the close has a particular meaning: people have often borrowed to trade a position and they want to leave that position before the close, particularly at the end of each session or before weekends. If they do not, they risk the market moving against them at the next open, and risk additional costs for holding borrowed money during a period where there's no trading. Thus, you may prefer to use the close because that's what many traditional traders do, even though it has less meaning to Bitcoin, and even less meaning for hourly closes.

If your analysis is directed at trading, you might want to try https://quant.stackexchange.com/


Warning Newbie: How does a Ledger hold multiple currencies?

You've discovered that with a Hierarchical Deterministic wallet like the Ledger, a single 24-word phrase can be used to derive (essentially) infinite public/private key pairs and addresses.

This standard is a combination of:

BIP32 - HD Wallets

BIP39 - Mnemonic code
and

BIP44 - Multi-account hierarchy

Notice that BIP44 takes that seed phrase and standardizes a series of values that make up a "path" from the seed phrase to a specific key:

m / purpose' / coin_type' / account' / change / address_index

That coin_type value I believe is the answer to your question.

Satoshi Labs (developer of the Trezor hardware wallet) maintains a list of values for the coin_type field here: https://github.com/satoshilabs/slips/blob/master/slip-0044.md

This list is accepted as standard by many hardware wallet manufacturers and cryptocurrency software developers although it's important to note that there are no consensus rules around it - just compatibility standards between wallet applications.

SO, starting with your BIP39 seed phrase and using BIP32 derivation you can compute the first Bitcoin receive address for account 0 at this BIP44 path:

m/44'/0'/0'/0/0

Similarly, your first Ethereum private key will be computed from this path:

m/44'/60'/0'/0/0

That's how the keys for different currencies are all derived from the same single source of entropy.

The reason Ledger has this concept of "apps" is that many of these altcoins do not use the same signature scheme or transaction message digest as Bitcoin. So although the series of private keys for each currency can be computed arbitrarily by the device itself, once you have the key you need additional software for each use case to instruct the device what to do with that key.


The coinbase transaction is not relayed by the network. It is invalid except as the first transaction in a block.

A standalone miner generates the coinbase transaction itself.

In mining pools, the mining pool generates the coinbase, and sends it to the mining client.


Which programming languages support secp256k1?

The Bouncy Castle project allows for this and it runs on the Java VM (as was mentioned earlier) as well as the .NET Runtime. An example of using it in C# is shown in this blog post. You can use the .NET version from Visual Basic .NET (as well as any of the other languages on the CLR as well, obviously).

For C++, look at the Crypto++ library which supports secp256k1.


There are both security and privacy related issues that arise from address reuse.  Based upon your question you are less concerned with the privacy implications and more concerned with the security implications in this question.  I will discuss security first before briefly mentioning why the privacy implications are greater than the security implications.

Address Security

Bitcoin addresses are derived randomly by generating a private and public key pair.  When an address is generated both the private and public keys are secret to everyone except the owner of the wallet.  At this point your address has 100% security assuming the device that it is stored on is not compromised already.  When you provide someone with your bitcoin address to send you funds they do not learn anything about the public or private keys even though the address is derived from the public key.  So far so good, right?

The first issue/security risk I will discuss is a specific implementation issue in a mobile wallet library.  It is worth knowing how a bitcoin transaction is structured to understand this issue but without getting too technical you may want to read this article about what happened when the same K value is used in multiple signatures.  When this issue arose it was trivial to derive the private key protecting the funds in question and attackers we able to steal a reported 55+ bitcoins.  As part of a bitcoin transaction the public key associated with the address is revealed to the network.  This allows the blockchain to validate that indeed that public key is associated with the address sending funds.  It also validates that the signature provided could only be generated by the private key associated with the public key which was now revealed.  If the user that were attacked did not reuse addresses and sent all of the funds stored out of this address to a new address after spending some of the funds, the new address would be 100% secret again.  This issue has been fixed and should only represent a concern if you are using a wallet that has not had a proper cryptographic audit.

The next class of security issues I will touch upon is side channel attacks.  These kind of attacks can become technical in discussion very fast so I will not go into details but essentially specific hardware platforms can be made to leak information about their current state thus allowing an attacker to determine random values the CPU will generate in the future.  This again allows the k value (also known as the ephemeral key) to be leaked and private keys can be recreated.   One such side channel attack know to target ECDSA is the FLUSH and RELOAD attack.

Although side channel attacks are unlikely to be performed on someone randomly without targeting it would be much easier to attack someone that is not using privacy preserving techniques.  Which leads me to briefly touch on the privacy aspects of address reuse.

Privacy Concerns

The first thing to consider when deciding whether or not to reuse your bitcoin address is that privacy not only impacts yourself when using bitcoin it also impacts everyone else that you transact with.  Using blockchain analysis it is trivial to determine which companies you may be doing business with, how much money you could be holding, as well as your complete ledger history of everyone that your address has transacted with.

There has been tracking attempts that also work to associate addresses with each other and "collapse identities" based upon transactions that are public for everyone to see on the blockchain.  Addresses that are downstream from your known address could be used to make illegal or purchases that could catch the interest of law enforcement and this could lead them to your doorstep because of association with particular transactions.

Read more about why you should not reuse addresses including 2 real world examples of unscrupulous activity that could occur if someone knew how much money you had stored or earned over a regular schedule (such as payroll).


Your file is in the directory:

…/hash2.js

while the script module is in

…/src/script.js

The relative path between these two would be ./src/script while your file is prescribing to find it in ../../script.
Once you correct the relative path, your program should be able to find the module.


Can mining puzzles be made socially valuable?

To be valid as a proof of work a problem needs to

be difficult to produce, and it's difficulty must scale up and down as the network speed requires. The levels of difficulty must be quite granular, bitcoin's go down to several decimal places to ensure an even blocktime.
have no central issuer, the work must be independently creatable and verifiable. No central authority should be needed to produce problems and solutions.
be quick to verify even on microprocessors, every node in the network must verify it 300,000 times over to synchronize with the blockchain today. Currently I can verify a sha256 merkle tree proof on a processor that costs a few cents in bulk;  scrypt coins are almost useless in that you need a huge amount of memory to verify the proofs.

Nothing else can fit this bill at all. Primecoin attempted this, but it's method has removed the ability for SPV clients to operate (kilobytes of stupid number strings in the block headers), and the work it produces (certain types of prime numbers in a sequence) is merely a curiosity rather than anything usable by anybody.

It must be a cryptographic hash. The simple fact that it is protecting the network means that it is not "useless".


Do all people mining the next block use the same transactions to form the Merkle tree?

No. This can arise because miners choose transactions differently (I say there shouldn't be free transactions!) or because a transaction is only known about by 90% of the network.

  I'm mining the transactions ABC and you are mining XYZ. If so, if I find a block that contains ABC, will I then mine the XYZ transactions?

That depends on why you didn't include XYZ in your first block.

If you didn't include them because you don't know about them, then you won't.
If you didn't include them because they didn't pay enough fees, then you might.
If you didn't include them because there wasn't enough space in the block, then you probably would.

  If I find a block, you will have to check which transactions were included in the block by me, before forming the next merkle tree, right? If not, you might use, for example, the B transaction again, which was already confirmed by me.

Yes. Mining clients download and fully validate blocks before mining on top of them.


Why I can't transfer from BTC trading wallet to my BTC wallet? using Blockchain

First, make sure there isn't a "hold period" on your recently deposited funds. Many exchanges that do business in the USA put a 7-day "hold" on all your deposits, meaning you can trade cryptos on that exchange all you want, but until those 7 days are over, you can't withdraw anything, or transfer crypto to an outside wallet.
Also, as mentioned in the comments, make sure that you have enough funds in your trading account to cover your transfer PLUS the transaction fee, and 5hat you are not trying to transfer less BTC than whatever their "minimum transfer amount" is currently set to.


This is not possible beyond providing both nodes identical own copy of the chain before initial sync. Both nodes will attempt to acquire their Bitcoin data resources via the P2P network independently, and index these accordingly, so they cannot share the same store.

What is possible though is to configure the nodes to be permanently maintain a peer connection to each other. TX and Blocks organized by one peer will be seen and then organized by the other.


In case of a grouped transaction, how to determine who sent what to whom?

How can I determine (if it is possible) what amount sender A sent to receiver B , instead having the balance for each participant ?

You pretty much can't. Often times, transactions like these are created for the purpose of making it difficult to determine which inputs are sending money to which outputs. Such transactions are called CoinJoins, so named because multiple people are joining their coins together in one transaction.

There are some techniques for determining which outputs are created by which inputs, but these techniques are not foolproof and often make assumptions that are not guaranteed. In fact, many software that make Coinjoin transactions are designed to make those assumptions non-viable and thus break such analysis so that the participants in the CoinJoin have more financial privacy.


Are change addresses generated on the fly or pre-generated with wallets?

There are different possible approaches.

Most current wallet software uses HD wallets, where keys and addresses are generated as needed from a master seed.  In this case, a change address would likely not be generated until it is needed.  A new address would be generated for each new transaction as this is better for privacy.

With Bitcoin Core, prior to the implementation of HD wallets, the default was to pre-generate 100 addresses and store the keys in wallet.dat as a "keypool". Change addresses would then be taken from the keypool, again using a new one for each transaction.  This was done so that each time you backed up wallet.dat, you would also be able to protect the keys for transactions you hadn't yet made.  Without this behavior, you would have to back up wallet.dat immediately after every new transaction - and if your disk crashed between the transaction and the backup, you would lose coins.

Some wallet software used to only generate one address and use it for all incoming transactions as well as change.  This is no longer common, though some wallets still provide it as an option.


Why does txID generation consider signatures?

If the signature was not part of the transaction protected by the hash, then you could have two different transactions, one valid and one invalid, with the same transaction ID. The primary purpose of the transaction ID is to permit agreement on whether a transaction is valid or not. So excluding the signatures from the hash would make transaction IDs unsuitable for their primary purpose.

One proposal for dealing with malleability attacks it to have a second transaction ID just for the purpose of defeating such attacks. This transaction ID wouldn't cover the signatures. But it wouldn't be suitable for checking transaction validity, forcing a system in which there are two types of transaction identifiers.


Does bitcoind store timestamp at which private key was imported?

No, bitcoind does not. bitcoind does store a timestamp for keys however this timestamp is used to determine when to start rescanning. importprivkey does not allow you to specify this timestamp, so in order to be sure to not miss any transactions, the timestamp is set to 1 indicating that the entire blockchain will be rescanned.

The importmulti command allows you to specify the timestamp which by default is the time at which you imported the key. However, as mentioned earlier, since the timestamp is needed for rescanning, if it is not set to be early enough, the automatic rescan done at import time will not catch all of the transactions the key is involved in.

If you want to see the timestamps, you can use getaddressinfo to get the information for the address corresponding to the private key you imported. getaddressinfo will give you the timestamp in unix time.


Why does the Bitcoin core client use so much CPU time while synching?

I would imagine verifying all of the signatures of the blocks?

You are verifying every single script, every single signature for continuity. You are making sure nobody is spending coins they're not allowed to. You're making sure all the rules are followed.

  Essentially doing the same calculation the miners seek to do and just checking their answers?

Yes, in addition to the above. You are verifying every block has a valid Proof Of Work. This takes two SHA256 operations though, versus the billions of billions a miner needs to do.


What happens if an ISP isolates a portion of nodes?

Yes, but this would only work if said ISP would host more than 50% of all the full nodes in the network. This is simply not the case, the nodes in the network are too widely distributed for that.


How can a Bitcoin transaction be used multiple times (If it is so)?

What is spent it's not the transaction itself, but the outputs the transaction has created. A transaction can have multiple outputs with different bitcoin amount hold on each one.

Therefore, a transaction can be "used", in the sense you expressed it, as many times as outputs it has.


What Bitcoin profitability calculators account for taxation on miner income?

None do now and none likely will anytime soon.

This will vary per-tax jurisdiction and per individual circumstances because income taxes are based on profit not on revenue.

This is the very first inquiry I've seen where this feature has been requested, incidentally.


transaction that was included in a block without my permission

Note that there is a difference between a wallet and an address. Namely, a wallet may control the keys for many addresses.

Checking the address you posted, it clearly has no bitcoins in it, as they have been transferred out to two different addresses:

15748uoft3CUiwvAqzPrLNxNxKNRpKpjt6

1EnD6fRsuajQm6B2KkYENE86nEvoinTjU8

If your wallet controls these addresses then you have nothing to worry about.

If not, then I’m sorry to say it appears your BTC was stolen. You’ll want to never use that wallet again, and it may be with spending some time trying to uncover how your wallet was hacked. Did you share login or wallet backup/seed info with anyone? Did you back it up to a potentially compromised email or Dropbox account? Etc

Your chance of recovering those coins is likely very slim, so at least you can try to learn from a past mistake.


ListWalletDir: Access is denied D:\System Volume Information

This long standing issue should be fixed in https://github.com/bitcoin/bitcoin/pull/21907.


How does lost BTC affect the market in the long run?

The price of bitcoin is affected by demand and scarcity.

Scarcity decreases as more bitcoin are mined (up until the 21 million bitcoin limit is reached---this is the maximum number that can ever be mined), which decreases the price. Scarcity increases as coins are lost (e.g. through the destruction of a wallet), or just held indefinitely (e.g. the ~1 million bitcoins of Satoshi Nakamoto that 'may' never get spent). Therefore, with demand staying above the number of coins available the price will continue to increase (as people are willing to pay more to be the one able to buy the coins, beating out the others also wanting to buy them).

Now obviously if we look far ahead (assuming bitcoin survives long enough), there is the foreseeable problem that ultimately the number of bitcoins in circulation will decrease to the point that eventually one satoshi (0.00000001 BTC), the minimum value one can currently hold, will be worth more than a desired minimum, e.g. one could be worth $2000, limiting bitcoin's use to only larger transactions. Thankfully the number of decimal places in bitcoin isn't a hard limit, so this could be increased in the future such that it wouldn't matter if there were even only one bitcoin in the world.


What are the limits of the bitcoin protocol for making thousands of transactions, and what are the alternatives?

There are systemic limits based on storage per block.  So the limit isn't the number of transactions, the limit is instead the amount of data all transactions for inclusion in a block consume all together.

The definition of a "microtransaction" varies.

Bitcoin might be used to send a transaction without a fee if it is not a microtransaction.  The Bitcoin-Qt/bitcoind client (and thus nearly all mining capacity) has special rules that if any outputs are under 0.01 BTC (currently about $5 USD), then it must include at least the minimum fee.

The minimum fee, when required, is 0.0005 BTC per KB of data.

In all likelihood then, all of your transactions would need to pay a fee.

However, simply paying a fee is no guarantee that a transaction will be included.   The blocks have a limit of 500KB but as storage climbs above 250KB the fees needed for each additional KB increase.  As space for blocks begin filling, those transactions with the higher fee will bump out those with a lower fee, which will need to wait to be included in a later block.

So to answer your question is not what the limits of the protocol, but what level of a fee in the future will be necessary for a transaction. That's something that is not known today, but most all will agree Bitcoin probably won't work well for transactions worth a fraction of a dollar especially if the value of the fee itself is in the "many cents" per transaction range.

Alternatives

Decentralized crypto currencies are decentralized to make them resistant to corruption.

But a decentralized currency can be used as the form of money on a centralized service.  Most online gambling sites using bitcoins deal in bitcoin denominated microtransactions, and only use the bitcoin network whan a customer adds funds or when a user withdraws their funds.  So that is an example of how Bitcoins can still be used for a service that deals in microtransactions.

Other methods:

Open Transactions is a technology that allows an issuer to receive bitcoins and issue bitcoin vouchers. Those vouchers can them be transacted on one or more Open Transactions servers.

Ripple is a distributed transaction system which might be able to handle your problem.  Bitcoins are one of the types of funds that can be transacted.


Bitcoin purchased but not received into my wallet

If your wallet is a custodial wallet where the private keys are managed by the provider, your only recourse is to contact the provider.

If your wallet is a non-custodial wallet where you manage the private-keys yourself, there are several possibilities

check that your wallet is fully synchronised.  How you do this depends on which wallet you use.
check the transaction by entering the transaction-id at several blockchain explorers. The business or person you bought the bitcoins from will be able to tell you the transaction-id and receiving address (it might have been printed on a receipt, mentioned in an e-mail or in a text-message etc)
check that the output of the transaction was sent to the correct Bitcoin-address. You can see the actual recipient addresses of the transaction in a blockchain explorer. Your wallet should be able to show you a list of the receive-addresses it has generated. Wallets nowadays generate a new receive-address for every transaction.


Three numbers after dash in transaction id

It's the index of the output in the transaction that credits you.

It's a bit of an unused format; typically ':n' is used, rather than '-nnn'.

This is because an entry in the transaction ledger doesn't really corresponding to one transaction, but to one output of it. For example, a transaction could have multiple outputs that all credit you.


No.  In the reference client, main.cpp runs this check during "AcceptBlock":

    // Check that all transactions are finalized
    BOOST_FOREACH(const CTransaction& tx, block.vtx)
        if (!IsFinalTx(tx, nHeight, block.GetBlockTime()))
            return state.DoS(10, error("AcceptBlock() : contains a non-final transaction"),
                             REJECT_INVALID, "bad-txns-nonfinal");

which rejects your block if it contain a non-final transaction.  A client that accepts a block containing a transaction with a locktime in the future and sequence number less than std::numeric_limits<unsigned int>::max() would be on the losing side of a fork.


What happens if R is not revealed by one of Lightning Network nodes? (Payment cancelation)

The situation is less worse than you seem to assume. If node C disappears the channel A,B won't be affected. Also there is no direct need to affect the channel B, C and C, D. So most channels will stay open.

The payment process is a two stage process and it depends during which stage of the process node C disappears to see what happens and how nodes react.

First stage: setting up htlcs from A to D. If C disappears before the htlcs have reached C the onion /payment is cancelled. No channel will be closed. Otherwise the resolution of the second stage takes place.

Second stage: preimage is propagated. Node D might force close the channel to settle the htlc on chain. In that case B could also see the preimage on chain an settle off chain. C has time to come back and claim money from B. If C is away too long C will have lost money sich B will have won. If D has settled before C disappears C will not be incentivesed to disappear as C could not get Reimbursed by B.

So we see the only channel that might break in such a situation is the C,D channel. But in any cases only C can loose money / funds by disappearing. This C is Incentivised to stay online and be responsive


The formula for the conversion can be found on the bitcoin wiki.

Essentially, the first byte indicates the number of trailing 0 bytes (minus 3 for some reason). The remaining 3 bytes are the next 3 bytes of the target.

So 0x1d00fffff has 0x00ffff followed by 0x1d - 3 = 26 trailing 0 bytes with the whole thing padded out to 32 bytes. So the final result is 0x00000000ffff00000000000000000000000000000000000000000000000000000.


JSON RPC library unable to connect to bitcoind?

As @Bittylicious mentioned the JSON-RPC is a little bit buggy

https://en.bitcoin.it/wiki/API_reference_(JSON-RPC)#PHP

Note: The jsonRPCClient library uses fopen() and will throw an exception saying "Unable to connect" if it receives a 404 or 500 error from bitcoind. This prevents you from being able to see error messages generated by bitcoind (as they are sent with status 404 or 500).

You have an option use EasyBitcoin instead, that will throw more accurate error messages and its pretty much the same than JSON-RPC

<?php
 require_once 'YOUR_FOLDER/easybitcoin.php';
 $rpc_host = 'YOUR_IP';
 $rpc_port = 'YOUR_PORT';
 $rpc_user = 'YOUR_USER';
 $rpc_pass = 'YOUR_KEY';
 $bitcoin = new Bitcoin($rpc_user, $rpc_pass, $rpc_host, $rpc_port);
 print_r($bitcoin->getinfo());
 print_r($bitcoin->listaccounts());
 print_r($bitcoin->listreceivedbyaddress(0, true));
?>

Hope this helps!


Where can the private key from a bitaddress.org paper wallet be redeemed?

A paper wallet has a private key ("Redeem") and a Bitcoin address ("Load & Verify").

You can import the private key in the Bitcoin-Qt/bitcoind client using the Debug console or the command line API.
You can import the private key into Mt. Gox (Funding, then Redeem, Private key) and it will sweep the funds to your exchange E-Wallet account.
You can import the private key into Blockchain.info/wallet
You can import the private key from a mobile by scanning using EasyWallet.org
(fee applies)
You can import a private key into the Multibit client and possibly with other clients.
You can spend using a private key with Brainwallet.org <-- Be careful with this.


While attempting to fetch a particular block my node just gets disconnected by peers?

Usually when a node is stuck it is due to local corruption causing the node to incorrectly believe a block is invalid. But in those cases the logs will reflect the invalid blocks. Instead we don't see any invalidity here but the node is continually trying to get the block and getting disconnected.

This situation can be caused by overly aggressive anti-virus which is falsely detecting data in a block as malicious and cutting the connection.  Sometimes this kind of filtering is applied to the general public by nation-state level  filtering but it also shows up on office networks and in some home setups (e.g. in windows AV software).

For sonicwall you can see the disconnections in the firewalls logs and disable the filtering entirely by going into the firewall settings under sonicwall->manage->security services->gateway-antivirus and unchecking "Enable Gateway Anti-Virus", or by whitelisting the false positive match for the particular host in question.

(Thanks to Ken on IRC who had this actual issue, and for telling me how he disabled it on the sonicwall)


Are Bitcoin ASICs Optimized for Fixed Length Messages?

What do you mean by "really long"? If it's bigger than (2^64-1)/8 bytes (~2,097,152 terabytes) then it's not going to work anyway because this is the theoretical limit of SHA256 and on top of that it would take a huge amount of time to complete, but then again I am not aware of many computers that can hold such great amounts of data.

For significantly smaller inputs it all comes down on the way the ASIC's SHA256 engine is implemented, what is the size of message (input) block in bits, how much memory is available per core in your SHA256 ASIC, etc. As per market standard, these cores are usually equipped with 128 kilobytes of memory. Of course nothing stops you from deploying external units of DRAM memory chips across memory-bus enabled ASICs but this will fire back in processing speed anyway.


What does the prefix of the raw transaction encoding of an exported Electrum transaction file (.txn) mean?

It stands for:

45505446 - EPTF - Electrum Partial Transaction Format
ff - Separator
00 - EPTF Version - This is currently always 0.

You can verify this quickly by running a python interpreter.

Python 3.6.7 (default, Oct 22 2018, 11:32:17)
[GCC 8.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> b'EPTF\xff'.hex()
'45505446ff'


What would happen if a portion of the Bitcoin network was separated from the rest of the network?

When bitcoin client downloads two conflicting blockchains, in other words when fork happened, it chooses the longer blockchain as valid, and the shorter becomes invalid and called "orphan blocks". "Length" is calculated as total combined difficulty of that chain, not number of blocks. Wiki: Block Chain

So in your scenario, Armenia most likely has less hashing power then the rest of world and it would produce shorter fork of blockchain, therefore it would be overrided after connection is restored.

51% attack implies coordinated effort from a small group of people with malicious intent, which is not the case according to your scenarion, therefore I wouldn't call 51% attack.

It would be easy to counter any negative outcome because users of isolated network would know instantly about the problem from sudden drop of total network hash power, and would just need to avoid spending bitcoins until connection is restored.


฿ price comes from whichever API you use. I prefer Coindesk because it does a weighted average, but Blockchain.info is another good option, as is Bitstamp or Coindesk.

From there you can use Bittrex API or Cryptsy or Poloniex.

There's also specialist API like gem.io or blockcypher.com


Multisig doesn't work unless all keys were generated from the current wallet?

The built-in multisig support in the reference client is only a proof-of-concept. As until recently (and still) the wallet did not deal well with coins being spent outside of its control, it was decided to only allow spending multisig coins when you have all keys. Of course that completely defeats the purpose of multisig, but proper support for it requires separate tools anyway (to pass the partially signed transactions around, etc).

However, the planned watch-only wallet support does allow watching multisig addresses too (in fact, any script at all), which will appear in listunspent. Clearly, the regular sendtoaddress & co RPCs cannot spend these coins, but it does give the ability to track them.


Most exchanges aren't publishing this data, some even trying to hide as much of it as possible, using separate wallets and trying to be smart about change progression.
A lot of the analytic companies are using repositories (examples:1, 2) of publicly known addresses to find out the wallet ownership.
But this isn't the most optimal solution when it comes to analytics, some blockchain analytic companies are actually applying as customers of these exchanges and trying to get on-chain activity, main addresses (so-called hotwallets) and marking wallets through common input clustering.


Why do I get 5 bytes worth of 0x00 hex values in both outputs?

The value of an output in a transaction is a 8-byte field encoded in little-endian. The value is always represented with 8 bytes no matter how small it is. Here you have the full transaction structure with sizes:


Electrum 2.7.9 setup never went through the password and seed setup, now I can't send coins

Apparently, without either password or seed, an Electrum wallet is not recoverable.

But let's reconstruct how it happened and see what you perhaps could do:

Electrum doesn't create a new wallet during setup only when there is already an Electrum wallet on the system.

It therefore seems likely that you or another user of your computer had installed Electrum on that computer before. Perhaps you should try to figure out if the seed and/or password was recorded back then, but you had forgotten about it. Else, you should first try likely passwords.

If you cannot make any progress with that, you might want to consider getting in touch with https://walletrecoveryservices.com/. I cannot personally vouch for them, but they appear to have helped a load of people in the past. They may be able to help you recover your password, if you have any idea about what you may have used.

Thanks to #electrum on freenode for most of the above information.


In Ethereum, gas is a measure of computational effort. To each operation, a fixed amount of gas is assigned (e.g. adding two numbers costs 3 gas, calculating a hash costs 30 gas, sending a transaction costs 21000 gas [1]).

Since computation is expensive (mind that it has to be done by every full node in the network), excessive consumption of gas needs to be discouraged. Therefore, each unit of gas must be paid for (in Ether) by the sender of the transaction that triggered the computation.

Unfortunately, it is often not easy and in general even impossible to know in advance how much gas a transaction will need eventually. Therefore, transactions have a gas limit field to specify the maximum amount of gas the sender is willing to buy. If the gas used exceeds this limit during execution, processing is stopped. The sender still has to pay for the performed computation, but they are protected from running completely out of funds.

The transaction gas limit also protects full nodes from attackers, who could, without a gas limit, make them execute effective infinity loops. If such a transaction would take longer than one block to process, it could never be included in a block, and, thus, the attacker wouldn't need to pay for it. [2]

Additionally, blocks, too, have a field called gas limit. It defines the maximum amount of gas all transactions in the whole block combined are allowed to consume. Similar to the maximum block size in Bitcoin (measured in bytes), its purpose is to keep block propagation and processing time low, thereby allowing for a sufficiently decentralized network. In contrast to Bitcoin, it is however not a constant. Instead, miners have the option to increase or decrease it every block by a certain factor. [3]

[1] See the Yellow Paper for a breakdown of operations and the respective gas costs (Appendices G and H)
[2] https://github.com/ethereum/wiki/wiki/Design-Rationale#gas-and-fees
[3] See the Yellow Paper Equations 40 to 42 for the exact rules


Difference between coinbaseaux.flags vs. coinbasetxn.data?

When the mutation "coinbase" (see BIP 23) is present, the key "coinbaseaux" sets rules for what MUST be in a coinbase if/when one is built/modified.

The key "coinbasetxn" is optional, and if omitted the mutation "coinbase" is assumed and the implication is that "coinbaseaux" MAY define requirements for building the coinbase.

The key "coinbaseaux" is also optional, however its omission has no implications according to BIP 23.


How can someone verify the signature of a Bitcoin ECDSA signature without knowing the signer's public key?

Simple, the sender shows the pubkey when spending from whatever address the bitcoins are in. As part of the verification, the receiver (actually, every node in the network), can verify that the pubkey hashes to the address given and then and only then verifies the signature.


Which wallet libraries officially intend to use Bech32 addresses, and will the addresses generated by them be compatible?

Bech32 is an address format that was only recently proposed. While its design had input from multiple wallet authors, it is way too early to say anything about adoption.

It is important to realize that there is no hurry about this. Every usable address type is available through embedding in P2SH, which is compatible with every wallet created the past few years.

At some point we'll need the higher efficiency and security that native SegWit outputs offer, but that is dependent on SegWit both activating, and being available in both sender and receiver wallets.

Disclaimer: I'm the author of the Bech32 proposal.


Is there a type of signature that will be valid in a transaction with multiple inputs/outputs that are unknown at the time of signing?

I think there is no "trick" :-) Maybe I don't fully understand your logic with "later by someone else". But maybe this helps you to get along:
I would think about a smart contract with CHECKSEQUENCEVERIFY, where you have a condition, that get's redefined, when a certain time has passed (after a specific amount of blocks have been mined). A very short idea could be this (baseline idea, no real code!):

OP_IF
   OP_DUP OP_HASH160 [PUBKEYHASH Alice] OP_EQUALVERIFY OP_CHECKSIG
OP_ELSE
   [blocks to pass] OP_CHECKSEQUENCEVERIFY OP_DROP
   OP_DUP OP_HASH160 [PUBKEYHASH "someone else"] OP_EQUALVERIFY OP_CHECKSIG
OP_ENDIF

This translates into this logic:
Alice can spend the tx anytime, but when a certain amount of blocks happened, then someone else can spend the tx.

It wouldn't matter, from "where" someone else spends the tx, if it is a single transaction with one input (aka Alice' Satoshis), or with many inputs from other tx. The spending condition for "someone else" is independant from the tx, in which it appears.

There is no wallet I'm aware of, that allows to realise the above condition via a graphical interface. It would have to be handcrafted... (aka "coded").

===================

Update after comments section has been worked through (28 March 2018)

Understanding your point corectly, you want to extend an existing tx with additional tx. To my knowledge there is no wallet which allows to do this. With the help of some command line tools one can get to the goal. A standard tx looks like this:

VERSION
TX_IN COUNT (e.g. 9 input structures)
 TX_IN[0]
  TX_IN[0] prev TX hash, OutPoint index, Script Length, Script Sig, Sequence
 TX_IN[1]
  TX_IN[1] prev TX hash, OutPoint index, Script Length, Script Sig, Sequence
 TX_IN[n]
  TX_IN[n] prev TX hash, OutPoint index, Script Length, Script Sig, Sequence

TX_OUT COUNT (e.g. 9 output structures)
 TX_OUT[0]
  TX_OUT[0] Value, PK_Script, pk_script
 TX_OUT[1]
  TX_OUT[1] Value, PK_Script, pk_script
 TX_OUT[n]
  TX_OUT[n] Value, PK_Script, pk_script
LOCK_TIME

So if the unsigned tx from Alice needs to go into this structure (of someone else), there are three things to get it correct:

you need to extract the V_in and V_Out from Alice transaction
need to integrate these parts in the model above, and update the
TX_IN and TX_Out counters
then the "someone else" would have to sign the tx...

The signing will be the complex part for someone else, cause somehow each input is signed with the corresponding privkey. So Alice would have to trust "someone else", and provide her privkey... If the privkey is not provided, the signature would stay invalid, and could not be sent into the network.

In general I was thinking, why one would do such an effort? For sure to save fees... As @willtech explained, exchanges collect many inputs into a single transaction, and then they have their corresponding privkey.

To get around this signing problem for Alice, one could think of a multisig. Then she doesn't need to provide her privkey to anyone.


what's inside empty blocks? what purpose does it serve?

what's inside those empty blocks? (i mean, what is "computationally expensive" from an empty item)

Empty blocks still contain data. They aren't devoid of data, they simply do not have transactions other than the coin generation transaction (known as the coinbase transaction) in them. Since an empty block does not contain any transactions from the Bitcoin network, it is considered to be empty. Empty blocks are still computationally expensive because miners still have to produce a Proof of Work. They still have block headers which are 80 bytes and have all of the fields that non-empty blocks do. They still have a list of transactions; but that list just contains one transaction, the coinbase transaction, which pays the miner the block subsidy.

  how can a system creates blocks that are empty and have no use (not for transactions use)

Empty blocks still have a use. They aren't completely useless. Firstly, they extend the blockchain adding additional work to the blockchain. The transactions that a block contains does not effect how much work needs to be done to mine the block, so empty blocks strengthen the security of the blockchain by adding to the cumulative work gone into the blockchain.

Empty blocks also introduce new coins to the Bitcoin system. They still pay miners for the work that they did, so new coins are generated and paid to the miner of that block. This is part of the coin generation transaction included in the block itself as the only transaction.

Additionally, when there are no transactions, the network still needs to move on. There still needs to be blocks mined, so empty blocks must be allowed in order for the blockchain to continue.

  what happen if there are transactions example like sending btc to other address but nobody mining it (verifying it through mining), will the transactions ever get through to the destined address?

If nobody ever includes a transaction in a block, then the transaction is never considered to be final. It will still appear in users' wallets as unconfirmed and they will see the coins. They can even spend the outputs of that transaction, but creating transactions from unconfirmed transactions is not advised. Such a transaction would also be unconfirmed so long as the first unconfirmed transaction remains unconfirmed.


In the case that I have free electricity, is mining worth it?

First, mining does not require a lot of bandwidth. Whatever you have is likely enough.

Second, mining profits (in bitcoin, not some currency after exchange) is determined by difficulty. Difficulty is like a level number. The higher it is, the harder it is for mining computers to hash (the under-the-hood work).

Calculating mining profits only needs the current difficulty and your hash rate. Google search "Bitcoin mining calculator" to use one of the many good ones available.

Regardless of electricity costs, mining on:

computer processors or graphics cards is going to yield a very low profit. Probably not worth your time.
AWS has probably been discussed before, but again will likely be far too low hashing power to be worth it, plus you'd have the service fees.
other's computers with JavaScript is a relatively new and interesting idea, but again is such a low hash rate that it's only worth it if you have thousands of clients running your script. There's also the dubious nature of the proposal (do you have permission?).

Mining on specialised hardware, called ASICs, is very profitable if you don't consider electricity. But current models consume much, over 1000W all of them, and are very noisy and push out a lot of heat.


If i have rpcuser and rpcpassword of a remote bitcoin server,can i transfer that server's bitcoin to other address?

If the server is allowing remote connections to the rpc port (usually 8332) and they have rpcallowip set so that your IP address is allowed (e.g. it's set to 0.0.0.0/0), then yes, you can connect to the server and transfer all of the Bitcoin from the server to an address.


What are the key features of eMunie, a crypto-currency that's not a Bitcoin fork?

First off, if the eMunie guys can't provide a compelling answer, then stay away from it.

Second, they are making a lot of bold claims without backing them up.  For example:

immune to 51% problems but transactions are verified by only two hatchers, so it's unclear that is any better..
With eMunie, both hatchers would get a near equal share of that reward - So? Bitcoin already has worker pools which implement the same concept.
The main problem there is that you get a handful of miners with massive hash power - Citation needed. The majority of Bitcoin is mined in pools that payout most of their profits to their workers.   This does not concentrate the wealth.


Is buying bitcoin with paypal legal without laundering concerns?

While I’m not an attorney, the website you describe would be considered a “money transmitter business” (MTB) which, in the US, falls under the jurisdiction of The Dept. Of Treasury FinCEN (Finacial Crimes Enforcement Network) which has regulations to prevent money laundering with strict anti-money laundering (AML) policies. You would need to register with FinCEN and comply with their regulations to legally perform such transactions on your website regarding AML/KYC (KYC is Know Your Customer). MTB laws also vary from state to state when it comes to cryptocurrency exchange for fiat money or vice versa. Just make sure to consult with a lawyer before you go live to protect yourself.


Feb2018: an older request, I just answer it so that future research might reveal useful data :-)

To compose the redeem script for a P2WPKH, there is a fairly simple structure, I copied this mostly from here:

Start with OP_0, followed by the keyhash. Keyhash is calculated with  RIPEMD160(SHA256(public key)), similiar to "std" PKH. Do not use uncompressed pubkeys!

The P2SH redeemScript will then always have 22 bytes:

OP_0:    00
Length:  14
keyhash: (20 bytes)

The scriptPubKey is composed this way:

OP_HASH160 hash160(redeemScript) OP_EQUAL

and the address is the corresponding P2SH address with prefix 3.

Step by step explanation here :-)


How can "Lightning Loop Out" help me to receive more payments?

As mentioned in other questions here there is a difference between capacity and balance.

Currently you cannot change the capacity of a channel. So let us assume you have opened a channel with a capacity of 0.1 BTC

This means you can now send up to 0.1BTC but you cannot receive any BTC on that channel.

One you used this channel to pay an invoice for example with 0.04 BTC the capacity of the channel stays the same but now you can receive 0.04 BTC on that channel which we usually call inbound capacity and you can only send 0.06 BTC (not in one payment though since the max payment limit is currently a little above 0.04 BTC) the 0.06 BTC is caked your outbound capacity. Inbound and outbound capacity together reflect the channel balance.

What loop does is that it gives you an invoice (something to pay for) and reimburses you onchain. In this way you have moved some of your outbound capacity to become inbound capacity without the necessity to spend money by actually buying something. (though you technically pay a small fee for the service)

Hope that makes it clear (:


Why do people burn Bitcoin or other cryptocurrencies?

Counterparty coin is one instance I can recall that they burned 20+ bitcoins to prove they are "serious" about their project and from those burned coins they generated counterparty tokens. These tokens can be seen as proof that they are linked to burned bitcoins, but obviously doesn't give them the same bitcoin value. It's more of a: "Hey, I'm serious about my project. Here's proof that I'm going to work on my project by throwing away money, but I'll also generate new coins in its replacement".


How does the price of 1 BTC compare to other commodities?

http://pricedingold.com/charts/BTC-2010.pdf This is a comparision chart for btc vs. miligrams of gold i guess you could reverse it against history of silver or some other commodities. You can get the complete article here http://pricedingold.com/bitcoin/


The Bitcoin testnet has a very low difficulty. Usually there are few people who mine on testnet. However, occasionally there will be enough people mining on the testnet for the difficulty to increase. But when those people go away, the difficulty is too high for the remaining testnet miners.

To combat this, there is a special rule that resets the difficulty to 1 in order to keep the testnet running. Unfortunately the way that this rule works allows large miners to game it so that the difficulty is constantly low.

What we are currently seeing on the testnet is exactly that. Someone with a lot of hashrate is mining on the testnet and gaming the difficulty to be very low. This means that blocks will be found very quickly until this person stops mining on testnet.

Nothing is wrong with the testnet, and there is nothing wrong with your node or the Bitcoin Core software.


This is a common problem whose cause is not well known. You can try switching miners, switching flags, or switching OpenCL versions. Usually you can find a combination that resolves the problem. I've seen this question asked several times and I've not yet seen a solid answer.


How do I chose the address to send to in Electrum? Can i send from a new made address with no transactions?

There is no such thing as a send address in Bitcoin.  I've heard Electrum has a feature with a name like this, but it's misleading.  Bitcoin payments are often made to an address, but when you spend them, you don't encode any sort of address into the transaction---you just provide the information necessary to prove you controlled the private key that created the address that was paid in the previous transaction.
When you start Electrum for the first time, it generates a random 128-bit number (a number between 0 and 340282366920938463463374607431768211455) called a seed.  Electrum then turns this number into the seed phrase you see.  Each of the possible numbers has a different seed phrase.  It's an assumption of cryptographers than no one currently has the ability to try even a significant fraction of all the possible numbers (or phrases) to guess your particular number.

a. No. There is a mathematical relationship between your public keys and your seed, but it's another assumption of cryptographers that nobody can determine this relationship without your private seed.  (Specifically, they need a number derived from the seed called the chain code.)  So making Bitcoin transactions does not reduce your security.
No. As stated in #1, there is no from address in Bitcoin transactions.  Each of the transactions you create will reference one or more previous transactions where you received payment.
No.  Bitcoin is a pseudonymous system.  In order to receive bitcoins, you must have a public key.  In order to spend bitcoins, you must prove you control the private key corresponding to that public key.  There are ways to make it difficult for people to associate your Bitcoin transactions with your real-world identity, but (in my opinion) none of them are easy and reliable enough for Bitcoin novices like yourself.  I suggest you only use Bitcoin for transactions that you wouldn't mind becoming public at a later time.


How to get an address's balance with the bitcoin client?

By default, what is maintained by the 0.8 blockchain engine is:

All blocks
A database with all block headers, and the positions on disk for each block
A database that represents all unspent transaction outputs (UTXOs), indexed by txid, at the current tip of the block chain
Undo files that allow rewinding the effects of blocks on this set of UTXOs.

Nothing related to addresses or balances exists at this level. That is just a client-side representation of the data. The balance of a wallet is the sum of the values of the UTXOs that are spendable with the set of keys in the wallet. You could define the balance of an address as the sum of the values of the UTXOs assigned to a script matching a given address (and this is what several sites do), but presenting it this way is quite confusing - it makes many people think that Bitcoin transactions transfer value from one address to another. This is not true, they consume specific outputs of a previous transaction, and merge and split those into new outputs.

The -txindex option you mention, adds one more thing that is maintained by the validation engine:

A database with the positions on disk for each transaction, indexed by txid.

This was added to make the getrawtransaction command work with historical transactions, but again, this has nothing to do with addresses. A database that indexes the UTXO set by address, or even the entire block chain history by address would be possible, but it would be relatively expensive to maintain, and shouldn't be necessary for normal operations (though it is quite useful for debugging...).

Where such things do belong, is in the wallet. The wallet as presented by the reference client does not use "balance of an address" - it rather sees addresses as entry points into the wallet, but manages the coins in the entire wallet together, regardless of what address they were last sent to. This also confuses people who are used to look at blockexplorer-like websites, when they realize that for example change is always sent to a fresh address.

So, to give a real answer: if you really want to track a balance, you need the wallet interface. Right now, this is quite unflexible, but there are plans to improve this situation soon. We'll hopefully soon get support for multiple wallets, and watch-only wallets, where you can just add addresses you'd like to track, without having their keys.


Have a look at the documentation (unfortunately it's in russian, but google can translate): https://btc-e.com/api/3/documentation

I think it's finished trades. Look at the Depth method to get open orders https://btc-e.com/api/3/documentation#depth
If you are looking at the btc_usd pair, then the price is in USD, and the amount in BTC


The signatures in Bitcoin (and Bitcoin Cash, Ethereum, and many other cryptocurrencies) are generated using elliptic curve curve cryptography. I found these videos very helpful in that regard:
https://www.youtube.com/watch?v=jQLmaBjYrk4

Other than that, you probably want to look into hash functions and asymmetric cryptography in general.

As a general introduction to cryptography, I took the cryptography course on Coursera which I can really recommend. This goes into the role of the adversary and what he can achieve. The teacher of this course, Dan Boneh, is, I believe, among the ten most renowned and best cryptographers in the world. On top of that, he is a very good teacher. The course does go into both symmetric and asymmetric cryptography but in the asymmetric field, it only teaches you RSA and Diffie-Hellman, not elliptic curves. Use the above videos for that.


What prevents anyone from spending utxos from a native segwit address?

Segwit is a soft fork.  A supermajority of miners have agreed that they will not include such transactions in their blocks, and will orphan any block that does include such a transaction.

If you send such a transaction to a legacy node, it will see it as a valid unconfirmed transaction, but the network will never confirm it.

Potentially, if there are still some miners running legacy code, the transaction could get included in a block by a miner who also sees it as valid.  But the majority of miners will reject this block.  The only way that the legacy node would ever see this transaction as reaching, say, 6 confirmations is if those legacy miners were to mine 6 blocks in succession.  Since those miners are at bet a tiny minority, this is extremely unlikely.

If you send the transaction directly to an updated miner, they'll reject it.  If you send it to a legacy miner, they might include it in a block, but then their block will eventually be orphaned out of the blockchain.


Possible to build a coin that will never change it's code?

Yes, it's trivially possible. All you have to do is never make any changes. Other people might make changes, but you are free to ignore them entirely if that's what you choose to do.

If the initial design is perfect, this should work out just fine. However, if there's anything wrong with the initial design at all or at some future point people consider it unsuitable, you will be stuck using a poor design. You might conceivably be the only person using that design, so it would cease to serve any purpose.

You will only be able to interoperate with people who believe as you do, of course. Just as they can't force you to change, you can't force them not to change.

But you could do it if that's what you really want to do. Nobody can force you to change things if you don't want to.


Lightning Network: what happens if parties lose their txs?

Yes that is correct. Bob's revocation secret is used as an insurance policy for Alice. If she loses it, Bob will be able to act maliciously and get away with it.

However, I want to add two things:

At least in c-lightning, there is the HSM secret. This serves as a 256-bit seed for an HD wallet from which all key pairs (for Commitment Txs as well as for Breach Remedy Txs) are being derived. Since the derivation in the lightning network is also deterministic, Alice should be able to reconstruct her keys (which she still needs in order to spend the output of her Commitment Tx).
If eltoo gets implemented (which requires a bitcoin soft-fork and acceptance of BIP118), the situation changes since there are no revocation keys needed anymore.


Can ASIC miners easily be used to guess brainwallet passphrases?

What follows is an educated guess, not certain statements, and is based on Electrum's brainwallet phrases (just figured it'd be a good example), not other schemes or human-generated ones.

No, a miner can't easily be tricked into doing it (e.g. solely by a rogue pool), but can be programmed to try to crack brainwallet phrases. This is because ordinary hashing involves totally different inputs (a block header and nonce, hashed twice) than brainwallet cracking (a random 128 bit seed, hashed 100,000 times).

You'd do this by trying random 128-bit seeds, through Electrum's algorithm, which involves taking the seed and running 100,000 SHA256 hashes on it (maybe some other stuff I'm missing would make it more difficult). You can then do a few more calculations to come up with the addresses that the key generates, and check the blockchain to see if any of these match.

The current network hashrate is ~50,000,000 GH/s. If all of that were instead put towards breaking everybody's Electrum keys, and all it takes is the 100K hashes, there'd be 5*10^11 out of 2^128 checked every second. You could check all of the keys in about 2*10^19 years, or 1.6*10^9 times the age of the universe. While you'd probably get collisions long before this (dependent on how many Electrum-generated addresses are in use), I think this gives you an idea of the infeasibility of this sort of attack.


Why are companies selling mining hardware instead of using it themselves?

Companies that manufacture mining equipment don't just mine with their own hardware for a variety of reasons:

They may not be able to obtain low prices on electricity, making it more profitable for others to mine than for them to mine.
They may not be able to make use of the heat generated, making it more profitable for others to mine than for them to mine.
It's easier to get financing if you're going to make something you can sell.
They may prefer not to take the risk that mining will remain profitable.
The value of mining equipment depends on the value of bitcoins, which would be negatively affected by mining becoming too consolidated. So mining is more profitable if it's distributed.
It may be virtually impossible to mine profitably and they may be too smart to think otherwise.


How would you end up with more than two transaction outputs?

How is it then that a transaction can have four outputs? Is it possible to pay more than one person (address) in a single transaction?

Yes, a transaction can have several inputs and several outputs. Those inputs and outputs can belong to the same user or a different user. So user A and B could make a transaction that combines several of their addresses and send money to C and D in as many of their addresses as they see fit.

Actually the change address that you mentioned is not a special output; just an output that sends some money to any of your addresses.


When no Bitcoins are left to be mined, how will the Blockchain continue to be validated?

Mining rewards are not the only source of income for miners. There are also transaction fees. When there are no more bitcoins to be mined (happens around 2140) then miners would be mining for transaction fees only.


In an event when nobody mines the next block in the blockchain, how are the transactions supposed to get published into the blockchain?

They don't.  The blockchain is by definition a chain of mined blocks.  If nobody mines the next block, then the blockchain cannot grow, and no further transactions can be included in it.  Transactions will cease to be confirmed until somebody does mine another block.

Transactions can still be relayed over the peer-to-peer network, and nodes will verify their signatures and store them in their mempools, but there will be no real protection against double spending.  Someone might create two or more transactions which conflict; some nodes may store one and others may store the other.  No consensus will necessarily arise as to which one should be accepted as the "right" one.

If this state of affairs becomes permanent then the currency is effectively dead.


Is Bitcoin Hong Kong Exchange a legitimate trading platform?

They did not appear fraudulent, only overpriced.
But I only made a handful of transactions.
Anyway they are closed now, my wallet is still there.


Genesis block coinbase transaction without confirmations

Transaction confirmation is an external concept which tells you how difficult it is (in terms of probability) to remove that transaction from  the block that contains it due to reorganization of the blockchain.

Genesis block transaction is a special one as it is hardcoded in the source code and the entire Bitcoin blockchain is built on top of the Genesis block. Confirmation concept does not apply because you cannot remove this transaction from the Genesis block, as you will be building a completely different chain if you do so.

As a side note, the coinbase transaction is also not spendable.


How to generate specific private keys from 12-word backup and wallet address?

Mnemonic seeds are based on the BIP39 (seeds) and BIP44 (accounts/multiple currencies).

When deriving addresses, one uses a derivation path to get to a specific addresses. The default paths are defined in the BIP specs, but some wallets may use different ones due to an error or intentionally (for instance, Ledger's Vertcoin derivation uses Monero's derivation path due to a coding error).

You can use tools such as Ian Coleman's BIP39 tool (preferably offline) to play around with your seed and derivation paths until you see your addresses. The tool has preloaded the common paths, so you should usually be able to access your wallet pretty easily, unless you were using an extremely unusual client.

Many wallets also publish their derivation paths in their support pages, and you could pull your original wallet's path from there.

Wallets such as Electrum will also let you import a seed and specify the derivation path, saving you from having to generate and import individual keys.

As long as your seed was generated by a wallet that complies with BIP44, and you are importing it into another wallet that also complies with BIP44, you should be able to recover all your keys with no additional work.


Non-profit balking at linking bank account to BitPay

Suggest other ways to get from Bitcoins to USD. You could, for example, sell the coins with Coinbase or Bitstamp. My suspicion is that you are dealing with someone who doesn't like having only one option. With several options, you can explain the advantages and disadvantages of each one and you both can choose the best one. If that's BitPay, you should be able to explain why that's the right choice, and that should make him more comfortable.


Which wallets support spending partial amounts of btc from a cold storage address?

I have a "watch only address" of my cold storage in Electrum. In this watch only address I can see all tx, and as such also create tx. I just cannot sign it. So I create it, save it to USB stick, bring it to cold storage, sign it, and bring it back to deliver to the network. I would guess the same can also be done with core wallet.


I was given a bitcoin from a miner,

Are you sure you havent been tricked by a conman?

See

Bitcoin Mining as a Newbie (link wallet to another person's miner)
Reg: Watch only Address
How can I get a private key for this address
Unlocking a Private Key from watch status
Recovering the private key from a blockchain wallet address

  how do I put it in my wallet?

One fairly good way is

download a wallet such as "bitcoin core" from bitcoin.org. Some other wallets are also available. Never accept wallet software that is given or sent to you by someone over the Internet.
keep the private-key written on paper somewhere very very safe and never give the private key to anyone who asks for it.
ask the miner to send bitcoins to the address of your wallet.
wait for at least 6 confirmations of the transfer.

  how do I know what it is worth

If there is any mention of "testnet", it is worth nothing.

If you do not have the private keys, it is worth nothing to you.

If someone else also has the private keys, they can take the bitcoin and leave you nothing.

If its in a wallet that a miner created for you, its contents are probably worth nothing to you.

Note that "Bitcoin Cash" (BCH) is not Bitcoin (BTC) and may be worth less. The same applies to "Bitcoin Gold", "Bitcoin Diamond" and a huge number of other alternative cryptocurrencys (altcoins). Don't confuse them.

Otherwise you can find the exchange rate from BTC (bitcoin) to USD (or any other currency) using a search engine. For example google BTC USD exchange rate

  I am new at this

Be very very careful. Lots of conmen prey on people who are new to this.


Why does every "defi" thing only support garbagecoins and never Bitcoin?

Bitcoin is pushing most use cases and applications to second layers (e.g Lightning, sidechains) because blockchains don't scale. Most "DeFi" apps use the blockchain for transactions, filling up blocks and raising onchain transaction fees. Development is easier if you assume blockchains scale and can stay decentralized as they scale (which they can't).
It is true that Ethereum's Solidity is more expressive than Bitcoin Script (allows for infinite loops etc) but you can still do a lot with Bitcoin Script. Ethereum has found a niche of making it very easy to issue tokens and selling them at vast prices. It is much harder to support an infinite number of tokens moving over say Lightning where channels are primarily denominated in Bitcoin.
There are some projects buildings "DeFi" like applications on Lightning e.g. discreet log contracts (DLCs) but it takes a lot longer to build if you actually want to keep it decentralized rather than merely labelling it "Decentralized" (De).


Sending funds on same block of received funds. Confirm sending not received?

They don't have to be on the same block, but as they do depend on each other the BobD->Bob transaction can only be mined if Alice->BobD is already in the same or an earlier block. If not, the entire block would be invalid and noone would accept it.

Note that smart miners would add up the fees for both transactions and on the basis of that decide whether to include it in a block or not. So Alice->BobD might have 0 fee and therefore not be interesting for miners, but if BobD->Bob pays enough fee to compensate for it, a miner might include both transactions in the same block. This is known as Child Pays For Parent or CPFP. I don't think it's very common yet for miners to have this implemented at the moment. Are there any pools or large miners running "child pays for parent" patch?


Not only can the nonce be varied, but also some information in the scriptSig of the coinbase transaction in the block, which would change the merkle root, so there should always be enough to find a hash within the target.

The difficulty of finding a block is recalculated every 2016 blocks to give an average time of 10 minutes between blocks. Because of the sheer amount of processing power going into the network, this is pretty reliable, its just not going to take an entire week. If blocks were taking longer than expected, the difficulty would reduce at the next retarget to compensate.


How do I build and review a Bitcoin Core GUI pull request?

It is difficult to answer this question as I don't know what your current skillset is. You will need some basic command line and Git experience and you will need a GitHub account. I will assume these as prerequisites for the sake of brevity.
(There is a great free introduction from Tracy Osborn to command line here. There is a free Codeacademy course on Git here.)
I will take an example PR from the Bitcoin Core GUI repo (PR 86) which was opened by hebasto, a Bitcoin Core contributor, adding a Tor icon to the GUI. At the time of writing (September 2020) it is open but it will hopefully be merged in the near future. Once it is merged hebasto may delete this branch (200902-tor) but this example will be illustrative regardless. You need to locate and build the branch that the PR author has been working on.

To build hebasto's PR branch (200902-tor) you can click on it and then you will be on hebasto's fork of the Bitcoin Core GUI repo. You will need to clone hebasto's fork. You do this by clicking the green Code button and then clicking on the link you need to clone. In this case it is https://github.com/hebasto/gui.git.

Once you have the link you need to clone go to your Terminal and use the git clone command. In this example it will be:
 git clone https://github.com/hebasto/gui.git

Before you clone it you can choose where to clone it. Using mkdir and cd commands you can make a new directory and change to that directory before you run the git clone command.
Once you have successfully cloned hebasto's fork you can checkout hebasto's PR branch (200902-tor) using:
git checkout 200902-tor

Now you are ready to follow the Bitcoin Core build instructions for your operating system e.g. (MacOS, Unix, Windows etc)
If you are building the GUI remember to use the --with-gui flag when you ./configure.
For more detailed guidance on reviewing Bitcoin Core PRs see this excellent post from Jon Atack.


Sending confidential transaction amount to the receiver

In Elements Alpha, output "amounts" consist of 3 pieces of data:

The Petersen commitment to the value, blinded by the blinding factor.
The range proof, which can publicly prove that the value is within range [0..2^32-1] units (satoshis) without revealing anything about the blinding factor.
An ECDH ephemeral public key of the sender.

The latter is where the solution lies. Every confidential transactions address contains an ECDH public key of the receiver (the blinding key), in addition to normal P2PKH or P2SH data.

When a CT transaction is sent, the sender chooses an ECDH ephemeral private key, and combines it with the blinding key to derive a blinding seed. This seed is used as a basis for the random number generator to create the range proof. The public version of the ephemeral key is then written in the 3rd field of the amount.

When the receiver sees this ECDH ephemeral public key, he combines it with his private blinding key, to derive the same seed as the sender used. Using this same seed, he can "unwind" the range proof, and decode the secret information that was used when creating it: the value and the blinding factor. There is in fact space for another 2 kilobytes of data in the range proof, only visible to the receiver (or anyone holding the private blinding key).


I set my transaction fee too low 2 months ago and blockchain says "transaction invalid", will I get my coins back?

Contact the person you sent it to sometimes they can speed up a transaction. Like when i sent a small amount of btc to localbitcoins in 2017, the can see the transaction and somehow point their miners specifically at that transaction. Maybe i don't recall correctly.but it took like two weeks and that was a long time then. Sounds like it's getting far worse. Probably will continue to get worse and worse. Bitcoin could be completely obsolete in another 3 to 6 years because it will be so slow.
I think the only thing you can do is wait. There's no centralized regulations that you can complain to. Very to hear that. Next time increase the transaction fee. The fees are godawful and are ruining crypto.


There are a couple that may be what your looking for.....

Open Transactions - http://opentransactions.org/wiki/index.php?title=Main_Page
This is more general and not specifically targeted at Cryptocurrency, it seems pretty malleable and could be used for what you are describing.

https://counterparty.co/ - This is similar to above, and as I have only just recently found it cant say much, but also looks to do the job.


How do I reward a miner who made a block I like?

It seems obvious that you could just send some coin to the receiving address in the coinbase transaction, but usually, that address is for a large group of people.

For pools that payout via the generation transaction (cf. this one), it is not one address "for a large group of people," so you could not "send some coin to the receiving address" because there's not just one. (Generation transactions have no inputs by definition.)

Check with the particular pool (e.g., Eligius pool lists the winning miner in a column entitled "Contributor" here). Oftentimes they say who mined the block, and you can send them BTC directly.

Not all pools pay the miners via the generation transaction, but some do (Eligius and P2Pool were a few of the first to).

  When you're in a mining pool, if yours is the machine that finds the solution to a block, then you get a much larger reward than everyone else.

That's up to the rules of the particular mining pool. See this comparison of the different pools' reward strategies.


Mining on the testnet: how to configure bitcoin-qt?

It is possible that you found a block, but it got orphaned. Another miner may have found a block around the same time, and for whatever reason, the next miner to find a block chose to link to theirs instead of yours.

This happens a lot on testnet because of a special rule that if no block is found for 20 minutes, the difficulty drops temporarily to 1. When this happens, typically lots of people find blocks right away, and it's a toss up which one is used by the next miner.

You could inspect debug.log if you want to know exactly what happened.


How to send payment through a predefined route?

TL;DR. You need to specify --final_cltv_delta=144 option in the lncli queryroutes command.

Longer answer... When payment is routed through Lightning Network, each intermediate node has a potential ability to steal the funds being transferred. To prevent this from happening, intermediate nodes cannot move the money immediately, but only after a certain period of time. And within this period the funds can be claimed back by a legitimate owner.

final_cltv_delta option specifies this period of time (measured in the number of blocks) for the last node in the chain of hops. When you query routes, the default value is small (I believe it was 9 at some point). But this value is not accepted by most lnd nodes, which require a longer period of 144 by default.


Slush has made A bridge to feed Bitcoin exchange data to Sierra Chart.

Of course, if all you want is to look at a candlestick chart (and even if you want a bit more than that), there's always http://bitcoincharts.com/charts/.


Bitmain Antminer S2 Bitcoin Miner Stopped Booting - How to get it to boot up again?

I have a S2 Antminer since April 2014, and has been on for 6 months and stopped working recently (oct-2014). I can turn it on and it shows power, but the LCD is blank and when opening the cover to see if there is anything loose, everything seems fine. I tried to take out the MicroSD card that is connected to the controller card inside and I cannot seem to be able to see it on my computer. It doesnt detect at all.

If you bought your S2 from bitmain, ebay or amazon, contact the seller as the S2's have a 1 year warranty from manufacturer.

Bitmain now has a repair center in Denver, so the unit would not have to be shipped back to Hong Kong.


You are right that you will need significant volume to make substantial profits.

Which country are you located in? Some countries will also have very high regulatory startup costs, which is why you will see some exchanges deciding to block all users from some jurisdictions.

What would make your exchange different from the rest? Without a substantial marketing budget it is hard to attract a lot of volume. People like to trade on the exchanges with the highest liquidity and as a new exchange you would not have that.

Try to focus on building something unique. When you launch an exchange focus on building volume at first (a maker taker model fee model and a referral system may help with that). Profits should be your long term concern (not short term) assuming you have enough capital to run at a loss for a while.

Most importantly make sure you exchange is secure! Trustless decentralized exchanges should gain in popularity over time. Too many exchanges have absconded with funds or been hacked already


Are fees required for distribution when using NXT/Ardor Monetary System when distributing via one of the mining protocols?

I spoke with Bas and he mentioned that like with mining, the coins themselves aren't really sent but rather generated, in a similar manner with mining on Bitcoin. Because of this, there are no fees involved.

Regarding sending out the currencies though, they will need to have the native coin in order to send it out. So with Nxt, this would mean that the user would need to have NXT. On child chains on Ardor, such as IGNIS, users will need to have the native coin of the respective child chain the currency is created.


Sample programs written using python-bitcoinlib?

take a look at the example folder in bitcoinlib repo
https://github.com/petertodd/python-bitcoinlib/tree/master/examples


How to access Latest Transactions using the Blockchain.info api?

First of all, there's no way for blockchain.info to know which transactions you have and don't have if it's not in a block.

You can get the full list of transactions not yet in a block using this call:

https://blockchain.info/unconfirmed-transactions?format=json

Otherwise, you can get a continuous stream of new transactions using the websocket API:

https://blockchain.info/api/api_websocket

You can subscribe to unconfirmed transactions by connecting via websocket to

wss://ws.blockchain.info/inv

and sending this:

{"op":"unconfirmed_sub"}

That socket will receive every transaction that blockchain.info receives.


configure: error: No working boost sleep implementation found

Found the problem. Had these lines in my .bashrc and commenting them out fixed it:

alias gcc="gcc-8"
alias g++="g++-8"
export CC="gcc"
export CXX="/usr/bin/gcc-8"
export PATH=/usr/local/clang_8.0.0/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/clang_8.0.0/lib:$LD_LIBRARY_PATH

Why this caused ./configure to error out, I have no idea. But problem solved.