Blockchain.info offers limited functionality, it is however sets the fee according to your size automatically for you. This doesn't mean it is doing a good job though. That is why I said think about changing your wallet.

You can however calculate an estimated size if you insist on using BC.I. A rough estimate is this:
ref

The funny thing is RBF existed from very early version and it was added in 0.12.0 and I can not find it in bitcoin core (0.13.0 I should upgrade soon :/) apart from mempool which is about relaying the RBF transactions not making them.

Read Things to do as sender > #1 (use a tool like http://bitcoinfees.21.co/ to determine the best fees next time) your transaction must have had less than 140 satoshis/byte fee
Read General > #3

Also think about changing your wallet.

Please READ:

I am not sure which board to post this in!
Please avoid any off-topic discussions here.
If you found any mistakes (technical or grammatical) please tell me.

Because of the fact that bitcoin blocks can only include a certain number of transactions (to reach the maximum consensus block size) and also the fact that number of transactions (for reasons beyond scope of this topic) has gone up, mempool is growing and more transactions are waiting to be included in a block.
In this topic I'll try to give some guidelines about what to do in order to get faster confirmations and also get rid of stuck transactions.


General things you need to know (as both receiver and sender):
1) A common novice mistake about fee:
Fee is calculated based on "size in bytes" not "size as in amount" which means it doesn't matter if you send 10BTC or 0.01BTC as far as fees are concerned. If you have are spending many outputs and create multiple new outputs the size of your transaction in bytes will be high and you have to pay higher fee.

2) A very important thing to know
Transaction can be reversed until it is confirmed. in other words you do not own the received bitcoins until the transaction has at least 1 confirmation.

• If you run a full node and in normal network status: 3 confirmation is Highly reliable
• If you are running an SPV wallet: 6 confirmation is Highly reliable
• In case of emergencies 30 confirmation is suggested (this is not common) More information here

3) Ask a miner directly to mine your transaction, this may not be free.
You can use ViaBTC accelerator tool. Read the details on the ViaBTC website.
If nothing else worked, you can contact Quickseller (Please include your transaction ID when contacting Quickseller to speed up the process) which does it as a volunteer work. He will then ask you to
- Confirm the transaction is not any kind of double spend, or attempt to harm any entity
- Pay a fee to f2pool payout address
He can then push your transaction to f2pool and the next block that f2pool mines will include your transaction.


Things to do as sender:
1) Pay Appropriate amount of fees!
New versions of most wallets have dynamic fees based on current status of mempool and previous blocks' fees and they suggest an appropriate amount of fee automatically based on your transaction size and an estimate of how fast it will be confirmed. you can also use a tool like http://bitcoinfees.21.co/ to see what an appropriate fee/byte currently is.

2) RBF
Opt-in Replace-by-fee allows you to replace your previous transaction that had lower fees with a new one that has a higher amount of fee. To put simple when you initially send a transaction with Opt-in RBF, you are telling the network that you may resend the same transaction with higher fees.
In the end it depends on the miners who mine the next block and whether or not they support opt-in RBF.
Electrum (v2.7.0+) allows creating RBF transactions.


3) Double Spend.
Double spending is spending the same outputs, and in case your transaction didn't have enough fees and it wasn't and RBF transaction the only other way is to double spend and include higher fees.
The problem with this method is that most nodes will see the double spend and not accept or relay the transaction.
Either wait for the transaction to fall out of the mempool (be forgotten) or if you run a full node such as bitcoin core abandon the transaction and start a new one.


Things to do as receiver:
1) Contact the sender
Ask the sender to do one of the above suggestions to speed up the process. Generally ask them to include higher fees.

2) CPFP:
Child Pays For Parent means the receiver spends an unconfirmed transaction output and includes enough fee covering the first (unconfirmed output) and the new (his own transaction).
This can only be done If your wallets allows spending unconfirmed transactions (it can still be done by creating a transaction manually and then signing it with your wallet)
Not all miners support CPFP
Advanced technical details (BIP125)

I think this was an account delete https://bitcointalk.org/index.php?topic=12156.0 (Linking the thread since there is no user account ) Username Atlas

In that case they have to pass the address which is a 16 bytes string inside the IP field.
For example from wiki:
mutqcuh7hwxmhx3k .onion
as hex: 6d757471637568376877786d6878336b

In case this is the way to do it, the result is not starting with 0s

Yeah, that is what confuses me too. I tried passing those hexes to my code trying to connect to those IPs but my Connect operation to the IP fails throwing a NotSupportedException, although this can also be because I am not behind Tor but the IPAddress.Parse also fails.

Some more examples, this time the list of Bitcoin Tor (Fallback) Nodes: https://en.bitcoin.it/wiki/Fallback_Nodes#IPv6_Nodes

I don't think so because .onion is a top level domain suffix and is used because they are not actual DNS name. I may be wrong but you don't necessarily need that for connecting to an IP address (another node).

As per your initial comment I also thought about that too, but since I've never seen a Tor IP I looked it up and here are 3 different examples I could find:



Here is the "tests" core uses to determine if an IP is Tor: https://github.com/bitcoin/bitcoin/blob/master/src/test/netbase_tests.cpp#L42-L61
The example uses this IP: "FD87:D87E:EB43:edb1:8e4:3588:e546:35ca"

I am very interested in knowing more about this, since I have been learning more about this topic myself.

I have spent a couple of hours on this, in the morning and the only thing I could come up with is that maybe the node is reporting false information, the protocol is forgiving about these things!

You may want to read the RFC3493 on the standard for reporting IPV6 addresses.

The examples are these IP addresses:
::70d1:c525:1979:3031
::3d5a:7e06:5c3e:bc67
And the only time they start with 0 is the deprecated IPv4- compatible IPv6 address but again this format doesn't math that either!
   |                80 bits               | 16 |      32 bits        |
   +--------------------------------------+--------------------------+
   |0000..............................0000|0000|    IPv4 address     |
   +--------------------------------------+----+---------------------+


Compact representation of IPV6 removes the 0s and replaces them with ::
2001:0000:4137:9e76:0c5b:0558:bcb8:e3dd -> 2001:0:4137:9e76:c5b:558:bcb8:e3dd
0000:0000:0000:0000:0000:ffff:b3b8:24c1 -> ::ffff:b3b8:24c1

also some other methods of Encoding

I am sorry that I can not help you more than this. But you can take a look at these links maybe they can be of some help:
https://github.com/search?l=JavaScript&q=blockr.io&type=Repositories&utf8=%E2%9C%93
https://github.com/search?l=JavaScript&q=smartbit&ref=searchresults&type=Repositories&utf8=%E2%9C%93
These are wrappers on blockr.io and smartbit.com Api written in JavaScript.

Also you can ask your questions on stackoverflow.com or reddit.com JavaScript boards.

The problem is that I don't know anything about this language you are using.

Try adding a header indicating your contentType and set it to application/json

This is what I do in C#
A quick and dirty work.

I fixed a mistake in my comment, you have to push what you have in the last line not a string, and not the whole JSON you have in above comment.
The JSON is a one parameter object with this format: {"hex":"TX_HASH"}
Replace TX_HASH with the transaction hash (the line before last, the string starting with 010000000194)

I don't understand the programming language you are using but I think your problem is that you are passing a wrong string as your hex parameter when you want to push.
When you call the url .../decode and take the response and put it in the decodedHex variable, then you are pushing decodedHex (which is a JSON) to .../push url.
If I understood your code correctly, that is a wrong approach.

In the second part you have to push a Raw transaction JSON like this {"hex":"TX_HASH"} not the whole JSON.
Take your transactionHex variable from the first part (line 5) and use that to push.

Transactions are stored on the blockchain not your paper wallet. Paper wallet is your private keys written on a paper. It is a bit similar to your email password and writing it on a piece of paper.

Yes.

Your public key is what you can give to others, which you see, store and give it to others as base58encrypted string (starts with 1 or 3).
And your private key is your secret information that you should never give anyone, and keep it safe. You usually see it as a base58encrypted string (starts with 5, L or K)

First of all please don't add unnecessary "size" to your comments it is annoying. Instead change the "zoom" level of your browser if you have trouble reading.

I'll try to explain:
What you need to know about bitcoin is that there is no such thing as "bitcoin" and you are not "storing coins" what you have is a private key which creates a public key, and record of all transactions that are stored on this public ledger called blockchain that peers hold on their computer when running a full node.

When you receive bitcoin, what happens is that some else is signing away the ownership of an output to your public key. And when you want to spend that output you sign away ownership of that output with your private key and give the ownership to another public key and all the records of these transactions between people are saved on the blockchain so your "database" is the blockchain.

What you do offline (generating a paper wallet) is that you are creating that private key to be able to receive those outputs and be able to spend them later.

For checking your paper wallet's balance, you go to that database (blockchain) and check your public key and see how many outputs were sent to your pubkey and add them up to see how much balance you've got. You do this usually by going to an online block explorer and typing in your bitcoin address (base58encrypted) starting with 1 or 3.

The code you are seeing in the example IS with fees! the variable called minerFee is the fee that you are paying and it is a fixed amount of 0.0001BTC.

Just change that line to anything you like, it can be a fixed amount or it can be a function taking the best amount of fee based on an API call such as this http://bitcoinfees.21.co/api

Or if you are doing it on top of a full node you can analyze the previous blocks to figure out the suitable fee.

I think you are not using NBitcoin library (https://github.com/MetacoSA/NBitcoin) instead you are using the example code. And in that example code according to the book (https://programmingblockchain.gitbooks.io/programmingblockchain/content/bitcoin_transfer/spend_your_coin.html) it is setting the fee amount to 0.0001BTC which means when you spend 0.0001BTC it deducts 0.0001 from your 0.0001 and is left with 0 so as a result it throws an exception

You need to debug the program yourself to make sure, I am mainly making assumptions based on what I see from the code and your explanation.

Well, I was just answering fikihafana (which seems to be a signature spammer!) since he said "learning purpose" and also I added two rather important things at the end of my comment if you take another look.

What wallets do for their coin selection (selecting which UTXO to spend) is that they either go for privacy or priority (I think the the priority approach is no longer applicable ref).
And for privacy they choose outputs in a way to protect the privacy, so if you have multiple address only spend outputs that are connected to addresses in one transaction.
* There may be other things wallets do for that, which I don't know or am forgetting now.

I am not sure what they do for dust but I believe if after making the transaction if there is any leftover (what you usually send to change address) and that leftover is smaller than dust amount, it is considered as fee (they don't send it to a change address).

Actually I don't agree with the trust part. Trust is earned over time, if any developer gives up because he has no history and no trust, development is over.
Also everything is open source and if it is good, it will get peer reviewed, you can see this on GitHub in the number of "Stars" and "watchers" and "contributors" and some other stuff.