// Download raw transaction from webbtc.com
func GetTxFromWebBTC(txid *btc.Uint256) (raw []byte) {
url := "http://webbtc.com/tx/" + txid.String() + ".bin"
r, er := http.Get(url)
if er == nil && r.StatusCode == 200 {
raw, _ = ioutil.ReadAll(r.Body)
r.Body.Close()
}
return
}
func GetTx(txid *btc.Uint256, vout int) bool {
r, er := http.Get("http://blockexplorer.com/rawtx/" + txid.String())
if er == nil && r.StatusCode == 200 {
defer r.Body.Close()
c, _ := ioutil.ReadAll(r.Body)
var txx onetx
er = json.Unmarshal(c[:], &txx)
if er == nil {
tx := new(btc.Tx)
tx.Version = txx.Ver
tx.TxIn = make([]*btc.TxIn, len(txx.In))
for i := range txx.In {
tx.TxIn[i] = new(btc.TxIn)
tx.TxIn[i].Input.Hash = btc.NewUint256FromString(txx.In[i].Prev_out.Hash).Hash
tx.TxIn[i].Input.Vout = txx.In[i].Prev_out.N
tx.TxIn[i].ScriptSig, _ = btc.DecodeScript(txx.In[i].ScriptSig)
tx.TxIn[i].Sequence = 0xffffffff
}
tx.TxOut = make([]*btc.TxOut, len(txx.Out))
for i := range txx.Out {
tx.TxOut[i] = new(btc.TxOut)
tx.TxOut[i].Value = btc.ParseValue(txx.Out[i].Value)
tx.TxOut[i].Pk_script, _ = btc.DecodeScript(txx.Out[i].ScriptPubKey)
}
tx.Lock_time = txx.Lock_time
rawtx := tx.Serialize()
curid := btc.NewSha2Hash(rawtx)
if !curid.Equal(txid) {
fmt.Println("The downloaded transaction does not match its ID.")
return false
}
ioutil.WriteFile("balance/"+curid.String()+".tx", rawtx, 0666)
return true
} else {
fmt.Println("json.Unmarshal:", er.Error())
}
} else {
if er != nil {
fmt.Println("http.Get:", er.Error())
} else {
fmt.Println("StatusCode=", r.StatusCode)
}
}
return false
}
// Download raw transaction from blockr.io
func GetTxFromBlockrIo(txid *btc.Uint256) (raw []byte) {
url := "http://btc.blockr.io/api/v1/tx/raw/" + txid.String()
r, er := http.Get(url)
if er == nil && r.StatusCode == 200 {
defer r.Body.Close()
c, _ := ioutil.ReadAll(r.Body)
var txx struct {
Status string
Data struct {
Tx struct {
Hex string
}
}
}
er = json.Unmarshal(c[:], &txx)
if er == nil {
raw, _ = hex.DecodeString(txx.Data.Tx.Hex)
} else {
println("er", er.Error())
}
}
return
}
func main() {
fmt.Println("Gocoin blockchain downloader version", btc.SourcesTag)
parse_command_line()
setup_runtime_vars()
if !add_ip_str(SeedNode) {
println("You need to specify IP address of a fast seed node.")
println("For example run it like this: downloader -s 89.31.102.237")
return
}
load_ips() // other seed nodes
if len(GocoinHomeDir) > 0 && GocoinHomeDir[len(GocoinHomeDir)-1] != os.PathSeparator {
GocoinHomeDir += string(os.PathSeparator)
}
if Testnet {
GocoinHomeDir += "tstnet" + string(os.PathSeparator)
Magic = [4]byte{0x0B, 0x11, 0x09, 0x07}
DefaultTcpPort = 18333
GenesisBlock = btc.NewUint256FromString("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")
fmt.Println("Using testnet3")
} else {
GocoinHomeDir += "btcnet" + string(os.PathSeparator)
}
fmt.Println("GocoinHomeDir:", GocoinHomeDir)
utils.LockDatabaseDir(GocoinHomeDir)
defer utils.UnlockDatabaseDir()
StartTime = time.Now()
if open_blockchain() {
fmt.Printf("Blockchain opening aborted\n")
close_blockchain()
return
}
fmt.Println("Blockchain open in", time.Now().Sub(StartTime))
go do_usif()
fmt.Println("Downloading headers from the seed peer", SeedNode)
download_headers()
if GlobalExit {
close_blockchain()
return
}
if DoThePings {
fmt.Println("Tuning to other peers and trying to find the fastest ones.")
fmt.Println("Execute command 'g' to continue to block chain download.")
fmt.Println("Otherwise it will auto-continue after 15 minutes.")
usif_prompt()
do_pings()
fmt.Println("Pings done.")
usif_prompt()
}
var HighestTrustedBlock *btc.Uint256
if LastTrustedBlock == "all" {
HighestTrustedBlock = TheBlockChain.BlockTreeEnd.BlockHash
fmt.Println("Assume all blocks trusted")
} else if LastTrustedBlock == "auto" {
if LastBlockHeight > 6 {
ha := BlocksToGet[LastBlockHeight]
HighestTrustedBlock = btc.NewUint256(ha[:])
fmt.Println("Assume last trusted block as", HighestTrustedBlock.String())
} else {
fmt.Println("-t=auto ignored since LastBlockHeight is only", LastBlockHeight)
}
} else if LastTrustedBlock != "" {
HighestTrustedBlock = btc.NewUint256FromString(LastTrustedBlock)
}
if HighestTrustedBlock != nil {
for k, h := range BlocksToGet {
if bytes.Equal(h[:], HighestTrustedBlock.Hash[:]) {
TrustUpTo = k
fmt.Println("All the blocks up to", TrustUpTo, "are assumed trusted")
break
}
}
} else {
fmt.Println("None of the blocks is to be assumed trusted (it will be very slow).")
}
for n := TheBlockChain.BlockTreeEnd; n != nil && n.Height > TheBlockChain.BlockTreeEnd.Height-BSLEN; n = n.Parent {
blocksize_update(int(n.BlockSize))
}
fmt.Println("Downloading blocks - BlocksToGet:", len(BlocksToGet), " avg_size:", avg_block_size())
usif_prompt()
StartTime = time.Now()
get_blocks()
fmt.Println("Up to block", TheBlockChain.BlockTreeEnd.Height, "in", time.Now().Sub(StartTime).String())
close_all_connections()
close_blockchain()
return
}
// Download (and re-assemble) raw transaction from blockexplorer.com
func GetTxFromExplorer(txid *btc.Uint256) ([]byte, []byte) {
url := "http://blockexplorer.com/rawtx/" + txid.String()
r, er := http.Get(url)
if er == nil && r.StatusCode == 200 {
defer r.Body.Close()
c, _ := ioutil.ReadAll(r.Body)
var txx onetx
er = json.Unmarshal(c[:], &txx)
if er == nil {
// This part looks weird, but this is how I solved seq=FFFFFFFF, if the field not present:
for i := range txx.In {
txx.In[i].Sequence = 0xffffffff
}
json.Unmarshal(c[:], &txx)
// ... end of the weird solution
tx := new(btc.Tx)
tx.Version = txx.Ver
tx.TxIn = make([]*btc.TxIn, len(txx.In))
for i := range txx.In {
tx.TxIn[i] = new(btc.TxIn)
tx.TxIn[i].Input.Hash = btc.NewUint256FromString(txx.In[i].Prev_out.Hash).Hash
tx.TxIn[i].Input.Vout = txx.In[i].Prev_out.N
if txx.In[i].Prev_out.N == 0xffffffff &&
txx.In[i].Prev_out.Hash == "0000000000000000000000000000000000000000000000000000000000000000" {
tx.TxIn[i].ScriptSig, _ = hex.DecodeString(txx.In[i].Coinbase)
} else {
tx.TxIn[i].ScriptSig, _ = btc.DecodeScript(txx.In[i].ScriptSig)
}
tx.TxIn[i].Sequence = txx.In[i].Sequence
}
tx.TxOut = make([]*btc.TxOut, len(txx.Out))
for i := range txx.Out {
am, er := btc.StringToSatoshis(txx.Out[i].Value)
if er != nil {
fmt.Println("Incorrect BTC amount", txx.Out[i].Value, er.Error())
return nil, nil
}
tx.TxOut[i] = new(btc.TxOut)
tx.TxOut[i].Value = am
tx.TxOut[i].Pk_script, _ = btc.DecodeScript(txx.Out[i].ScriptPubKey)
}
tx.Lock_time = txx.Lock_time
rawtx := tx.Serialize()
if txx.Size != uint(len(rawtx)) {
fmt.Printf("Transaction size mismatch: %d expexted, %d decoded\n", txx.Size, len(rawtx))
return nil, rawtx
}
curid := btc.NewSha2Hash(rawtx)
if !curid.Equal(txid) {
fmt.Println("The downloaded transaction does not match its ID.", txid.String())
return nil, rawtx
}
return rawtx, rawtx
} else {
fmt.Println("json.Unmarshal:", er.Error())
}
} else {
if er != nil {
fmt.Println("http.Get:", er.Error())
} else {
fmt.Println("StatusCode=", r.StatusCode)
}
}
return nil, nil
}