README.md

@@ -2,6 +2,8 @@
 
 # Blockbook
 
+**FOR INTERNAL GUARDA WALLET PURPOSES ONLY. PLEASE USE UPSTREAM INSTEAD!**
+
 **Blockbook** is back-end service for Trezor wallet. Main features of **Blockbook** are:
 
 - index of addresses and address balances of the connected block chain
@@ -11,6 +13,11 @@
 - support of multiple coins (Bitcoin and Ethereum type) with easy extensibility to other coins
 - scripts for easy creation of debian packages for backend and blockbook
 
+## For Guarda Dev Team
+
+ - Branch `guarda-changes` only for production use. DO NOT MERGE UNTESTED CHANGES!
+ - Branch `master` for compability with Trezor upstream. ONLY PRs FROM UPSTREAM ALLOWED!
+
 ## Build and installation instructions
 
 Officially supported platform is **Debian Linux** and **AMD64** architecture.

api/types.go

@@ -357,6 +357,7 @@ type Utxo struct {
 	Path          string  `json:"path,omitempty"`
 	Locktime      uint32  `json:"lockTime,omitempty"`
 	Coinbase      bool    `json:"coinbase,omitempty"`
+	ScriptPubKey  string  `json:"scriptPubKey,omitempty"`
 }
 
 // Utxos is array of Utxo

api/typesv1.go

@@ -92,6 +92,7 @@ type AddressUtxoV1 struct {
 	AmountSat     big.Int `json:"satoshis"`
 	Height        int     `json:"height,omitempty"`
 	Confirmations int     `json:"confirmations"`
+	ScriptPubKey  string  `json:"scriptPubKey"`
 }
 
 // BlockV1 contains information about block
@@ -205,6 +206,7 @@ func (w *Worker) AddressUtxoToV1(au Utxos) []AddressUtxoV1 {
 			Height:        utxo.Height,
 			Txid:          utxo.Txid,
 			Vout:          uint32(utxo.Vout),
+			ScriptPubKey:  utxo.ScriptPubKey,
 		}
 	}
 	return v1

api/worker.go

@@ -287,6 +287,7 @@ func (w *Worker) getTransactionFromBchainTx(bchainTx *bchain.Tx, height int, spe
 	var pValInSat *big.Int
 	vins := make([]Vin, len(bchainTx.Vin))
 	rbf := false
+	var rawTxForInputValues *bchain.TxForInValues
 	for i := range bchainTx.Vin {
 		bchainVin := &bchainTx.Vin[i]
 		vin := &vins[i]
@@ -353,6 +354,28 @@ func (w *Worker) getTransactionFromBchainTx(bchainTx *bchain.Tx, height int, spe
 				if vin.ValueSat != nil {
 					valInSat.Add(&valInSat, (*big.Int)(vin.ValueSat))
 				}
+			} else {
+				vin.AddrDesc = w.chainParser.GetAddrDescForUnknownInput(bchainTx, i)
+				vin.Addresses, vin.IsAddress, err = w.chainParser.GetAddressesFromAddrDesc(vin.AddrDesc)
+				if rawTxForInputValues == nil {
+					rawTxJSON, err := w.chain.GetTransactionSpecific(bchainTx)
+					if err != nil {
+						glog.Error("Can't retrieve raw transaction with id ", bchainTx.Txid, ":", err)
+					}
+					if rawTxJSON != nil {
+						rawTxForInputValues = &bchain.TxForInValues{Vin: make([]bchain.VinValues, 0)}
+						err = json.Unmarshal(rawTxJSON, rawTxForInputValues)
+					}
+				}
+				if rawTxForInputValues != nil && rawTxForInputValues.Vin != nil && len(rawTxForInputValues.Vin) > i {
+					inputValue, err := w.chainParser.AmountToBigInt(rawTxForInputValues.Vin[i].Value)
+					if err == nil && inputValue.Cmp(big.NewInt(0)) != 0 {
+						vin.ValueSat = (*Amount)(&inputValue)
+						if vin.ValueSat != nil {
+							valInSat.Add(&valInSat, (*big.Int)(vin.ValueSat))
+						}
+					}
+				}
 			}
 		} else if w.chainType == bchain.ChainEthereumType {
 			if len(bchainVin.Addresses) > 0 {
@@ -834,6 +857,7 @@ func (w *Worker) txFromTxAddress(txid string, ta *db.TxAddresses, bi *db.BlockIn
 	var err error
 	var valInSat, valOutSat, feesSat big.Int
 	vins := make([]Vin, len(ta.Inputs))
+	var rawTxForInputValues *bchain.TxForInValues
 	for i := range ta.Inputs {
 		tai := &ta.Inputs[i]
 		vin := &vins[i]
@@ -842,7 +866,30 @@ func (w *Worker) txFromTxAddress(txid string, ta *db.TxAddresses, bi *db.BlockIn
 		valInSat.Add(&valInSat, &tai.ValueSat)
 		vin.Addresses, vin.IsAddress, err = tai.Addresses(w.chainParser)
 		if err != nil {
-			glog.Errorf("tai.Addresses error %v, tx %v, input %v, tai %+v", err, txid, i, tai)
+			//glog.Errorf("tai.Addresses error %v, tx %v, input %v, tai %+v", err, txid, i, tai)
+		} else {
+			if vin.Txid == "" {
+				if rawTxForInputValues == nil {
+					bchainTx, err := w.chain.GetTransaction(txid)
+					rawTxJSON, err := w.chain.GetTransactionSpecific(bchainTx)
+					if err != nil {
+						glog.Error("Can't retrieve raw transaction with id ", txid, ":", err)
+					}
+					if rawTxJSON != nil {
+						rawTxForInputValues = &bchain.TxForInValues{Vin: make([]bchain.VinValues, 0)}
+						err = json.Unmarshal(rawTxJSON, rawTxForInputValues)
+					}
+				}
+				if rawTxForInputValues != nil && rawTxForInputValues.Vin != nil && len(rawTxForInputValues.Vin) > i {
+					inputValue, err := w.chainParser.AmountToBigInt(rawTxForInputValues.Vin[i].Value)
+					if err == nil && inputValue.Cmp(big.NewInt(0)) != 0 {
+						vin.ValueSat = (*Amount)(&inputValue)
+						if vin.ValueSat != nil {
+							valInSat.Add(&valInSat, (*big.Int)(vin.ValueSat))
+						}
+					}
+				}
+			}
 		}
 		if w.db.HasExtendedIndex() {
 			vin.Txid = tai.Txid
@@ -1684,6 +1731,7 @@ func (w *Worker) getAddrDescUtxo(addrDesc bchain.AddressDescriptor, ba *db.AddrB
 									AmountSat: (*Amount)(&vout.ValueSat),
 									Locktime:  bchainTx.LockTime,
 									Coinbase:  coinbase,
+									ScriptPubKey: vout.ScriptPubKey.Hex,
 								})
 								inMempool[bchainTx.Txid] = struct{}{}
 							}
@@ -1731,6 +1779,14 @@ func (w *Worker) getAddrDescUtxo(addrDesc bchain.AddressDescriptor, ba *db.AddrB
 							coinbase = true
 						}
 					}
+					bchainTx, height, err := w.txCache.GetTransaction(txid)
+					if err != nil {
+						if err == bchain.ErrTxNotFound {
+							return nil, NewAPIError(fmt.Sprintf("Transaction '%v' not found", txid), true)
+						}
+						return nil, NewAPIError(fmt.Sprintf("Transaction '%v' not found (%v)", txid, err), true)
+					}
+					transaction, err := w.GetTransactionFromBchainTx(bchainTx, height, false, false)
 					_, e = inMempool[txid]
 					if !e {
 						utxos = append(utxos, Utxo{
@@ -1740,6 +1796,7 @@ func (w *Worker) getAddrDescUtxo(addrDesc bchain.AddressDescriptor, ba *db.AddrB
 							Height:        int(utxo.Height),
 							Confirmations: confirmations,
 							Coinbase:      coinbase,
+							ScriptPubKey:  transaction.Vout[utxo.Vout].Hex,
 						})
 					}
 				}

bchain/coins/aryacoin/aryacoinparser.go

@@ -0,0 +1,64 @@
+package aryacoin
+
+import (
+	"github.com/trezor/blockbook/bchain/coins/btc"
+
+	"github.com/martinboehm/btcd/wire"
+	"github.com/martinboehm/btcutil/chaincfg"
+)
+
+// magic numbers
+const (
+	MainnetMagic wire.BitcoinNet = 0xe7eae188
+	TestnetMagic wire.BitcoinNet = 0xf1c8d2fd
+)
+
+// chain parameters
+var (
+	MainNetParams chaincfg.Params
+	TestNetParams chaincfg.Params
+)
+
+func init() {
+	MainNetParams = chaincfg.MainNetParams
+	MainNetParams.Net = MainnetMagic
+	MainNetParams.PubKeyHashAddrID = []byte{23}
+	MainNetParams.ScriptHashAddrID = []byte{5}
+	MainNetParams.Bech32HRPSegwit = "arya"
+
+	TestNetParams = chaincfg.TestNet3Params
+	TestNetParams.Net = TestnetMagic
+	TestNetParams.PubKeyHashAddrID = []byte{111}
+	TestNetParams.ScriptHashAddrID = []byte{196}
+	TestNetParams.Bech32HRPSegwit = "arya"
+}
+
+// AryaCoinParser handle
+type AryaCoinParser struct {
+	*btc.BitcoinLikeParser
+}
+
+// NewAryaCoinParser returns new AryaCoinParser instance
+func NewAryaCoinParser(params *chaincfg.Params, c *btc.Configuration) *AryaCoinParser {
+	return &AryaCoinParser{BitcoinLikeParser: btc.NewBitcoinLikeParser(params, c)}
+}
+
+// GetChainParams contains network parameters for the main AryaCoin network,
+// and the test AryaCoin network
+func GetChainParams(chain string) *chaincfg.Params {
+	if !chaincfg.IsRegistered(&MainNetParams) {
+		err := chaincfg.Register(&MainNetParams)
+		if err == nil {
+			err = chaincfg.Register(&TestNetParams)
+		}
+		if err != nil {
+			panic(err)
+		}
+	}
+	switch chain {
+	case "test":
+		return &TestNetParams
+	default:
+		return &MainNetParams
+	}
+}

bchain/coins/aryacoin/aryacoinrpc.go

@@ -0,0 +1,58 @@
+package aryacoin
+
+import (
+	"github.com/trezor/blockbook/bchain"
+	"github.com/trezor/blockbook/bchain/coins/btc"
+	"encoding/json"
+
+	"github.com/golang/glog"
+)
+
+// AryaCoinRPC is an interface to JSON-RPC bitcoind service.
+type AryaCoinRPC struct {
+	*btc.BitcoinRPC
+}
+
+// NewAryaCoinRPC returns new AryaCoinRPC instance.
+func NewAryaCoinRPC(config json.RawMessage, pushHandler func(bchain.NotificationType)) (bchain.BlockChain, error) {
+	b, err := btc.NewBitcoinRPC(config, pushHandler)
+	if err != nil {
+		return nil, err
+	}
+
+	s := &AryaCoinRPC{
+		BitcoinRPC: b.(*btc.BitcoinRPC),
+	}
+	s.RPCMarshaler = btc.JSONMarshalerV1{}
+	s.ChainConfig.SupportsEstimateFee = false
+
+	return s, nil
+}
+
+// Initialize initializes AryaCoinRPC instance.
+func (b *AryaCoinRPC) Initialize() error {
+	ci, err := b.GetChainInfo()
+	if err != nil {
+		return err
+	}
+	chainName := ci.Chain
+
+	glog.Info("Chain name ", chainName)
+	params := GetChainParams(chainName)
+
+	// always create parser
+	b.Parser = NewAryaCoinParser(params, b.ChainConfig)
+
+	// parameters for getInfo request
+	if params.Net == MainnetMagic {
+		b.Testnet = false
+		b.Network = "livenet"
+	} else {
+		b.Testnet = true
+		b.Network = "testnet"
+	}
+
+	glog.Info("rpc: block chain ", params.Name)
+
+	return nil
+}

bchain/coins/bitcoinvault/bitcoinvaultparser.go

@@ -0,0 +1,104 @@
+package bitcoinvault
+
+import (
+	"bytes"
+
+	"github.com/martinboehm/btcd/wire"
+	"github.com/martinboehm/btcutil/chaincfg"
+	"github.com/trezor/blockbook/bchain"
+	"github.com/trezor/blockbook/bchain/coins/btc"
+	"github.com/trezor/blockbook/bchain/coins/utils"
+)
+
+// magic numbers
+const (
+	MainnetMagic wire.BitcoinNet = 0xc0c0c0c0
+)
+
+// chain parameters
+var (
+	MainNetParams chaincfg.Params
+)
+
+// From https://github.com/bitcoinvault/bitcoinvault/blob/a6ab4e7a6dda8e2b8fda4a6c4a558bd412f23d89/src/policy/auxpow.h#L11
+// Except these are not block hashes, but their parent block hashes
+var FAKE_AUXPOW_PREFORK_BLOCK_PARENTS = map[string]bool{
+	"0000000000000000144c7fb7dad69be270035fa2d7f4652819369d9e3bb8023d": true,
+	"000000000000000017b3b639f6f4ff8618c0fe5fbc44c39fa924a60974be6a2d": true,
+	"0000000000000000022a3e19cd72f7012a2089fa5854ac42374bd48c010f1f4f": true,
+	"00000000000000001e8818e5c81c2f224fbf21f7be90888f4c6314bb56f11d3f": true,
+};
+
+func isFakeAuxpowPreforkBlockParent(hash string) bool {
+	return FAKE_AUXPOW_PREFORK_BLOCK_PARENTS[hash]
+}
+
+func init() {
+	MainNetParams = chaincfg.MainNetParams
+	MainNetParams.Net = MainnetMagic
+	MainNetParams.PubKeyHashAddrID = []byte{78}
+	MainNetParams.ScriptHashAddrID = []byte{60}
+	MainNetParams.Bech32HRPSegwit = "royale"
+}
+
+// BitcoinvaultParser handle
+type BitcoinvaultParser struct {
+	*btc.BitcoinLikeParser
+}
+
+// NewBitcoinvaultParser returns new BitcoinvaultParser instance
+func NewBitcoinvaultParser(params *chaincfg.Params, c *btc.Configuration) *BitcoinvaultParser {
+	return &BitcoinvaultParser{BitcoinLikeParser: btc.NewBitcoinLikeParser(params, c)}
+}
+
+// GetChainParams contains network parameters for the main Bitcoinvault network,
+// and the test Bitcoinvault network
+func GetChainParams(chain string) *chaincfg.Params {
+	if !chaincfg.IsRegistered(&MainNetParams) {
+		err := chaincfg.Register(&MainNetParams)
+		if err != nil {
+			panic(err)
+		}
+	}
+	switch chain {
+	default:
+		return &MainNetParams
+	}
+}
+
+// ParseBlock parses raw block to our Block struct
+// it has special handling for Auxpow blocks that cannot be parsed by standard btc wire parser
+func (p *BitcoinvaultParser) ParseBlock(b []byte) (*bchain.Block, error) {
+	r := bytes.NewReader(b)
+	w := wire.MsgBlock{}
+	h := wire.BlockHeader{}
+	err := h.Deserialize(r)
+
+	if err != nil {
+		return nil, err
+	}
+
+	if (h.Version & utils.VersionAuxpow) != 0 && !isFakeAuxpowPreforkBlockParent(h.PrevBlock.String()) {
+		if err = utils.SkipAuxpow(r); err != nil {
+			return nil, err
+		}
+	}
+
+	err = utils.DecodeTransactions(r, 0, wire.WitnessEncoding, &w)
+	if err != nil {
+		return nil, err
+	}
+
+	txs := make([]bchain.Tx, len(w.Transactions))
+	for ti, t := range w.Transactions {
+		txs[ti] = p.TxFromMsgTx(t, false)
+	}
+
+	return &bchain.Block{
+		BlockHeader: bchain.BlockHeader{
+			Size: len(b),
+			Time: h.Timestamp.Unix(),
+		},
+		Txs: txs,
+	}, nil
+}