// maybeAddOutpoint potentially adds the passed outpoint to the bloom filter
// depending on the bloom update flags and the type of the passed public key
// script.
//
// This function MUST be called with the filter lock held.
func (bf *Filter) maybeAddOutpoint(pkScrVer uint16, pkScript []byte, outHash *chainhash.Hash, outIdx uint32, outTree int8) {
switch bf.msgFilterLoad.Flags {
case wire.BloomUpdateAll:
outpoint := wire.NewOutPoint(outHash, outIdx, outTree)
bf.addOutPoint(outpoint)
case wire.BloomUpdateP2PubkeyOnly:
class := txscript.GetScriptClass(pkScrVer, pkScript)
if class == txscript.PubKeyTy || class == txscript.MultiSigTy {
outpoint := wire.NewOutPoint(outHash, outIdx, outTree)
bf.addOutPoint(outpoint)
}
}
}
func TestFilterInsertUpdateNone(t *testing.T) {
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateNone)
// Add the generation pubkey
inputStr := "04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c" +
"876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a" +
"2252247d97a46a91"
inputBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Add the output address for the 4th transaction
inputStr = "b6efd80d99179f4f4ff6f4dd0a007d018c385d21"
inputBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
inputStr = "147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"
sha, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewShaHashFromStr failed: %v", err)
return
}
outpoint := wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
return
}
inputStr = "02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewShaHashFromStr failed: %v", err)
return
}
outpoint = wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
return
}
}
func TestFindingSpentCredits(t *testing.T) {
t.Parallel()
s, teardown, err := testStore()
defer teardown()
if err != nil {
t.Fatal(err)
}
// Insert transaction and credit which will be spent.
recvRec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
t.Fatal(err)
}
err = s.InsertTx(recvRec, TstRecvTxBlockDetails)
if err != nil {
t.Fatal(err)
}
defaultAccount := uint32(0)
err = s.AddCredit(recvRec, TstRecvTxBlockDetails, 1, false, defaultAccount)
if err != nil {
t.Fatal(err)
}
// Insert confirmed transaction which spends the above credit.
spendingRec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
t.Fatal(err)
}
err = s.InsertTx(spendingRec, TstSignedTxBlockDetails)
if err != nil {
t.Fatal(err)
}
err = s.AddCredit(spendingRec, TstSignedTxBlockDetails, 0, false, defaultAccount)
if err != nil {
t.Fatal(err)
}
bal, err := s.Balance(1, TstSignedTxBlockDetails.Height, wtxmgr.BFBalanceLockedStake, true, defaultAccount)
if err != nil {
t.Fatal(err)
}
expectedBal := dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value)
if bal != expectedBal {
t.Fatalf("bad balance: %v != %v", bal, expectedBal)
}
unspents, err := s.UnspentOutputs()
if err != nil {
t.Fatal(err)
}
op := wire.NewOutPoint(TstSpendingTx.Sha(), 0, dcrutil.TxTreeStake)
if unspents[0].OutPoint != *op {
t.Fatal("unspent outpoint doesn't match expected")
}
if len(unspents) > 1 {
t.Fatal("has more than one unspent credit")
}
}
func TestFilterInsertUpdateNone(t *testing.T) {
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateNone)
// Add the generation pubkey
inputStr := "0270c906c3ba64ba5eb3943cc012a3b142ef169f066002515bf9ec1bd9b7e27f0d"
inputBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Add the output address for the 4th transaction
inputStr = "b6efd80d99179f4f4ff6f4dd0a007d018c385d21"
inputBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
inputStr = "147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"
hash, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err)
return
}
outpoint := wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
return
}
inputStr = "02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterInsertUpdateNone NewHashFromStr failed: %v", err)
return
}
outpoint = wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestFilterInsertUpdateNone matched outpoint %s", inputStr)
return
}
}
func TestFakeTxs(t *testing.T) {
// First we need a wallet.
w, err := keystore.NewStore("banana wallet", "", []byte("banana"),
wire.MainNet, &keystore.BlockStamp{}, 100)
if err != nil {
t.Errorf("Can not create encrypted wallet: %s", err)
return
}
a := &Wallet{
Wallet: w,
lockedOutpoints: map[wire.OutPoint]struct{}{},
}
w.Unlock([]byte("banana"))
// Create and add a fake Utxo so we have some funds to spend.
//
// This will pass validation because txcscript is unaware of invalid
// tx inputs, however, this example would fail in dcrd.
utxo := &tx.Utxo{}
addr, err := w.NextChainedAddress(&keystore.BlockStamp{}, 100)
if err != nil {
t.Errorf("Cannot get next address: %s", err)
return
}
copy(utxo.AddrHash[:], addr.ScriptAddress())
ophash := (chainhash.Hash)([...]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32})
out := wire.NewOutPoint(&ophash, 0)
utxo.Out = tx.OutPoint(*out)
ss, err := txscript.PayToAddrScript(addr)
if err != nil {
t.Errorf("Could not create utxo PkScript: %s", err)
return
}
utxo.Subscript = tx.PkScript(ss)
utxo.Amt = 1000000
utxo.Height = 12345
a.UtxoStore = append(a.UtxoStore, utxo)
// Fake our current block height so dcrd doesn't need to be queried.
curBlock.BlockStamp.Height = 12346
// Create the transaction.
pairs := map[string]int64{
"17XhEvq9Nahdj7Xe1nv6oRe1tEmaHUuynH": 5000,
}
_, err = a.txToPairs(pairs, 1)
if err != nil {
t.Errorf("Tx creation failed: %s", err)
return
}
}
// createSpendTx generates a basic spending transaction given the passed
// signature and public key scripts.
func createSpendingTx(sigScript, pkScript []byte) *wire.MsgTx {
coinbaseTx := wire.NewMsgTx()
outPoint := wire.NewOutPoint(&chainhash.Hash{}, ^uint32(0),
dcrutil.TxTreeRegular)
txIn := wire.NewTxIn(outPoint, []byte{OP_0, OP_0})
txOut := wire.NewTxOut(0, pkScript)
coinbaseTx.AddTxIn(txIn)
coinbaseTx.AddTxOut(txOut)
spendingTx := wire.NewMsgTx()
coinbaseTxSha := coinbaseTx.TxSha()
outPoint = wire.NewOutPoint(&coinbaseTxSha, 0,
dcrutil.TxTreeRegular)
txIn = wire.NewTxIn(outPoint, sigScript)
txOut = wire.NewTxOut(0, nil)
spendingTx.AddTxIn(txIn)
spendingTx.AddTxOut(txOut)
return spendingTx
}
// This example demonstrates manually creating and signing a redeem transaction.
func ExampleSignTxOutput() {
// Ordinarily the private key would come from whatever storage mechanism
// is being used, but for this example just hard code it.
privKeyBytes, err := hex.DecodeString("22a47fa09a223f2aa079edf85a7c2" +
"d4f8720ee63e502ee2869afab7de234b80c")
if err != nil {
fmt.Println(err)
return
}
privKey, pubKey := chainec.Secp256k1.PrivKeyFromBytes(privKeyBytes)
pubKeyHash := dcrutil.Hash160(pubKey.SerializeCompressed())
addr, err := dcrutil.NewAddressPubKeyHash(pubKeyHash,
&chaincfg.MainNetParams, chainec.ECTypeSecp256k1)
if err != nil {
fmt.Println(err)
return
}
// For this example, create a fake transaction that represents what
// would ordinarily be the real transaction that is being spent. It
// contains a single output that pays to address in the amount of 1 DCR.
originTx := wire.NewMsgTx()
prevOut := wire.NewOutPoint(&chainhash.Hash{}, ^uint32(0), dcrutil.TxTreeRegular)
txIn := wire.NewTxIn(prevOut, []byte{txscript.OP_0, txscript.OP_0})
originTx.AddTxIn(txIn)
pkScript, err := txscript.PayToAddrScript(addr)
if err != nil {
fmt.Println(err)
return
}
txOut := wire.NewTxOut(100000000, pkScript)
originTx.AddTxOut(txOut)
originTxHash := originTx.TxSha()
// Create the transaction to redeem the fake transaction.
redeemTx := wire.NewMsgTx()
// Add the input(s) the redeeming transaction will spend. There is no
// signature script at this point since it hasn't been created or signed
// yet, hence nil is provided for it.
prevOut = wire.NewOutPoint(&originTxHash, 0, dcrutil.TxTreeRegular)
txIn = wire.NewTxIn(prevOut, nil)
redeemTx.AddTxIn(txIn)
// Ordinarily this would contain that actual destination of the funds,
// but for this example don't bother.
txOut = wire.NewTxOut(0, nil)
redeemTx.AddTxOut(txOut)
// Sign the redeeming transaction.
lookupKey := func(a dcrutil.Address) (chainec.PrivateKey, bool, error) {
// Ordinarily this function would involve looking up the private
// key for the provided address, but since the only thing being
// signed in this example uses the address associated with the
// private key from above, simply return it with the compressed
// flag set since the address is using the associated compressed
// public key.
//
// NOTE: If you want to prove the code is actually signing the
// transaction properly, uncomment the following line which
// intentionally returns an invalid key to sign with, which in
// turn will result in a failure during the script execution
// when verifying the signature.
//
// privKey.D.SetInt64(12345)
//
return privKey, true, nil
}
// Notice that the script database parameter is nil here since it isn't
// used. It must be specified when pay-to-script-hash transactions are
// being signed.
sigScript, err := txscript.SignTxOutput(&chaincfg.MainNetParams,
redeemTx, 0, originTx.TxOut[0].PkScript, txscript.SigHashAll,
txscript.KeyClosure(lookupKey), nil, nil, secp)
if err != nil {
fmt.Println(err)
return
}
redeemTx.TxIn[0].SignatureScript = sigScript
// Prove that the transaction has been validly signed by executing the
// script pair.
flags := txscript.ScriptBip16 | txscript.ScriptVerifyDERSignatures |
txscript.ScriptDiscourageUpgradableNops
vm, err := txscript.NewEngine(originTx.TxOut[0].PkScript, redeemTx, 0,
flags, 0)
if err != nil {
fmt.Println(err)
return
}
if err := vm.Execute(); err != nil {
fmt.Println(err)
return
}
fmt.Println("Transaction successfully signed")
// Output:
// Transaction successfully signed
}
func TestInsertsCreditsDebitsRollbacks(t *testing.T) {
t.Parallel()
// Create a double spend of the received blockchain transaction.
dupRecvTx, err := dcrutil.NewTxFromBytesLegacy(TstRecvSerializedTx)
if err != nil {
t.Errorf("failed to deserialize test transaction: %v", err.Error())
return
}
// Switch txout amount to 1 DCR. Transaction store doesn't
// validate txs, so this is fine for testing a double spend
// removal.
TstDupRecvAmount := int64(1e8)
newDupMsgTx := dupRecvTx.MsgTx()
newDupMsgTx.TxOut[0].Value = TstDupRecvAmount
TstDoubleSpendTx := dcrutil.NewTx(newDupMsgTx)
TstDoubleSpendSerializedTx := serializeTx(TstDoubleSpendTx)
// Create a "signed" (with invalid sigs) tx that spends output 0 of
// the double spend.
spendingTx := wire.NewMsgTx()
spendingTxIn := wire.NewTxIn(wire.NewOutPoint(TstDoubleSpendTx.Sha(), 0, dcrutil.TxTreeRegular), []byte{0, 1, 2, 3, 4})
spendingTx.AddTxIn(spendingTxIn)
spendingTxOut1 := wire.NewTxOut(1e7, []byte{5, 6, 7, 8, 9})
spendingTxOut2 := wire.NewTxOut(9e7, []byte{10, 11, 12, 13, 14})
spendingTx.AddTxOut(spendingTxOut1)
spendingTx.AddTxOut(spendingTxOut2)
TstSpendingTx := dcrutil.NewTx(spendingTx)
TstSpendingSerializedTx := serializeTx(TstSpendingTx)
var _ = TstSpendingTx
tests := []struct {
name string
f func(*Store) (*Store, error)
bal, unc dcrutil.Amount
unspents map[wire.OutPoint]struct{}
unmined map[chainhash.Hash]struct{}
}{
{
name: "new store",
f: func(s *Store) (*Store, error) {
return s, nil
},
bal: 0,
unc: 0,
unspents: map[wire.OutPoint]struct{}{},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "txout insert",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, nil)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, nil, 0, false)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstRecvTx.Sha(): {},
},
},
{
name: "insert duplicate unconfirmed",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, nil)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, nil, 0, false)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstRecvTx.Sha(): {},
},
},
{
name: "confirmed txout insert",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstRecvTxBlockDetails)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, TstRecvTxBlockDetails, 0, false)
return s, err
},
bal: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "insert duplicate confirmed",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstRecvTxBlockDetails)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, TstRecvTxBlockDetails, 0, false)
return s, err
},
bal: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "rollback confirmed credit",
f: func(s *Store) (*Store, error) {
err := s.Rollback(TstRecvTxBlockDetails.Height)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstRecvTx.Sha(): {},
},
},
{
name: "insert confirmed double spend",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstDoubleSpendSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstRecvTxBlockDetails)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, TstRecvTxBlockDetails, 0, false)
return s, err
},
bal: dcrutil.Amount(TstDoubleSpendTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstDoubleSpendTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "insert unconfirmed debit",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, nil)
return s, err
},
bal: 0,
unc: 0,
unspents: map[wire.OutPoint]struct{}{},
unmined: map[chainhash.Hash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
{
name: "insert unconfirmed debit again",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstDoubleSpendSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstRecvTxBlockDetails)
return s, err
},
bal: 0,
unc: 0,
unspents: map[wire.OutPoint]struct{}{},
unmined: map[chainhash.Hash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
{
name: "insert change (index 0)",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, nil)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, nil, 0, true)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
{
name: "insert output back to this own wallet (index 1)",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, nil)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, nil, 1, true)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
wire.OutPoint{*TstSpendingTx.Sha(), 1, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
{
name: "confirm signed tx",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstSpendingSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstSignedTxBlockDetails)
return s, err
},
bal: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
wire.OutPoint{*TstSpendingTx.Sha(), 1, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "rollback after spending tx",
f: func(s *Store) (*Store, error) {
err := s.Rollback(TstSignedTxBlockDetails.Height + 1)
return s, err
},
bal: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
wire.OutPoint{*TstSpendingTx.Sha(), 1, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{},
},
{
name: "rollback spending tx block",
f: func(s *Store) (*Store, error) {
err := s.Rollback(TstSignedTxBlockDetails.Height)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[wire.OutPoint]struct{}{
wire.OutPoint{*TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular}: {},
wire.OutPoint{*TstSpendingTx.Sha(), 1, dcrutil.TxTreeRegular}: {},
},
unmined: map[chainhash.Hash]struct{}{
*TstSpendingTx.Sha(): {},
},
},
{
name: "rollback double spend tx block",
f: func(s *Store) (*Store, error) {
err := s.Rollback(TstRecvTxBlockDetails.Height)
return s, err
},
bal: 0,
unc: dcrutil.Amount(TstSpendingTx.MsgTx().TxOut[0].Value + TstSpendingTx.MsgTx().TxOut[1].Value),
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstSpendingTx.Sha(), 0, dcrutil.TxTreeRegular): {},
*wire.NewOutPoint(TstSpendingTx.Sha(), 1, dcrutil.TxTreeRegular): {},
},
unmined: map[chainhash.Hash]struct{}{
*TstDoubleSpendTx.Sha(): {},
*TstSpendingTx.Sha(): {},
},
},
{
name: "insert original recv txout",
f: func(s *Store) (*Store, error) {
rec, err := NewTxRecord(TstRecvSerializedTx, time.Now())
if err != nil {
return nil, err
}
err = s.InsertTx(rec, TstRecvTxBlockDetails)
if err != nil {
return nil, err
}
err = s.AddCredit(rec, TstRecvTxBlockDetails, 0, false)
return s, err
},
bal: dcrutil.Amount(TstRecvTx.MsgTx().TxOut[0].Value),
unc: 0,
unspents: map[wire.OutPoint]struct{}{
*wire.NewOutPoint(TstRecvTx.Sha(), 0, dcrutil.TxTreeRegular): {},
},
unmined: map[chainhash.Hash]struct{}{},
},
}
s, teardown, err := testStore()
defer teardown()
if err != nil {
t.Fatal(err)
}
for _, test := range tests {
tmpStore, err := test.f(s)
if err != nil {
t.Fatalf("%s: got error: %v", test.name, err)
}
s = tmpStore
bal, err := s.Balance(1, TstRecvCurrentHeight, wtxmgr.BFBalanceSpendable)
if err != nil {
t.Fatalf("%s: Confirmed Balance failed: %v", test.name, err)
}
if bal != test.bal {
t.Fatalf("%s: balance mismatch: expected: %d, got: %d", test.name, test.bal, bal)
}
unc, err := s.Balance(0, TstRecvCurrentHeight, wtxmgr.BFBalanceSpendable)
if err != nil {
t.Fatalf("%s: Unconfirmed Balance failed: %v", test.name, err)
}
unc -= bal
if unc != test.unc {
t.Fatalf("%s: unconfirmed balance mismatch: expected %d, got %d", test.name, test.unc, unc)
}
// Check that unspent outputs match expected.
unspent, err := s.UnspentOutputs()
if err != nil {
t.Fatalf("%s: failed to fetch unspent outputs: %v", test.name, err)
}
for _, cred := range unspent {
if _, ok := test.unspents[cred.OutPoint]; !ok {
t.Errorf("%s: unexpected unspent output: %v", test.name, cred.OutPoint)
}
delete(test.unspents, cred.OutPoint)
}
if len(test.unspents) != 0 {
t.Fatalf("%s: missing expected unspent output(s)", test.name)
}
// Check that unmined txs match expected.
unmined, err := s.UnminedTxs()
if err != nil {
t.Fatalf("%s: cannot load unmined transactions: %v", test.name, err)
}
for _, tx := range unmined {
txHash := tx.TxSha()
if _, ok := test.unmined[txHash]; !ok {
t.Fatalf("%s: unexpected unmined tx: %v", test.name, txHash)
}
delete(test.unmined, txHash)
}
if len(test.unmined) != 0 {
t.Fatalf("%s: missing expected unmined tx(s)", test.name)
}
}
}
// generateVote creates a new SSGen given a header hash, height, sstx
// tx hash, and votebits.
func (s *StakeStore) generateVote(ns walletdb.ReadWriteBucket, waddrmgrNs walletdb.ReadBucket, blockHash *chainhash.Hash, height int64, sstxHash *chainhash.Hash, defaultVoteBits stake.VoteBits, allowHighFees bool) (*StakeNotification, error) {
// 1. Fetch the SStx, then calculate all the values we'll need later for
// the generation of the SSGen tx outputs.
sstxRecord, err := s.getSStx(ns, sstxHash)
if err != nil {
return nil, err
}
sstx := sstxRecord.tx
sstxMsgTx := sstx.MsgTx()
// The legacy wallet didn't store anything about the voteBits to use.
// In the case we're loading a legacy wallet and the voteBits are
// unset, just use the default voteBits as set by the user.
voteBits := defaultVoteBits
if sstxRecord.voteBitsSet {
voteBits.Bits = sstxRecord.voteBits
voteBits.ExtendedBits = sstxRecord.voteBitsExt
}
// Store the sstx pubkeyhashes and amounts as found in the transaction
// outputs.
// TODO Get information on the allowable fee range for the vote
// and check to make sure we don't overflow that.
ssgenPayTypes, ssgenPkhs, sstxAmts, _, _, _ :=
stake.TxSStxStakeOutputInfo(sstxMsgTx)
// Get the current reward.
initSudsidyCacheOnce.Do(func() {
subsidyCache = blockchain.NewSubsidyCache(height, s.Params)
})
stakeVoteSubsidy := blockchain.CalcStakeVoteSubsidy(subsidyCache,
height, s.Params)
// Calculate the output values from this data.
ssgenCalcAmts := stake.CalculateRewards(sstxAmts,
sstxMsgTx.TxOut[0].Value,
stakeVoteSubsidy)
subsidyCache = blockchain.NewSubsidyCache(height, s.Params)
// 2. Add all transaction inputs to a new transaction after performing
// some validity checks. First, add the stake base, then the OP_SSTX
// tagged output.
msgTx := wire.NewMsgTx()
// Stakebase.
stakeBaseOutPoint := wire.NewOutPoint(&chainhash.Hash{},
uint32(0xFFFFFFFF),
wire.TxTreeRegular)
txInStakeBase := wire.NewTxIn(stakeBaseOutPoint, []byte{})
msgTx.AddTxIn(txInStakeBase)
// Add the subsidy amount into the input.
msgTx.TxIn[0].ValueIn = stakeVoteSubsidy
// SStx tagged output as an OutPoint.
prevOut := wire.NewOutPoint(sstxHash,
0, // Index 0
1) // Tree stake
txIn := wire.NewTxIn(prevOut, []byte{})
msgTx.AddTxIn(txIn)
// 3. Add the OP_RETURN null data pushes of the block header hash,
// the block height, and votebits, then add all the OP_SSGEN tagged
// outputs.
//
// Block reference output.
blockRefScript, err := txscript.GenerateSSGenBlockRef(*blockHash,
uint32(height))
if err != nil {
return nil, err
}
blockRefOut := wire.NewTxOut(0, blockRefScript)
msgTx.AddTxOut(blockRefOut)
// Votebits output.
blockVBScript, err := generateVoteScript(voteBits)
if err != nil {
return nil, err
}
blockVBOut := wire.NewTxOut(0, blockVBScript)
msgTx.AddTxOut(blockVBOut)
// Add all the SSGen-tagged transaction outputs to the transaction after
// performing some validity checks.
for i, ssgenPkh := range ssgenPkhs {
// Create a new script which pays to the provided address specified in
// the original ticket tx.
var ssgenOutScript []byte
switch ssgenPayTypes[i] {
case false: // P2PKH
ssgenOutScript, err = txscript.PayToSSGenPKHDirect(ssgenPkh)
if err != nil {
return nil, err
}
case true: // P2SH
ssgenOutScript, err = txscript.PayToSSGenSHDirect(ssgenPkh)
if err != nil {
return nil, err
}
}
// Add the txout to our SSGen tx.
txOut := wire.NewTxOut(ssgenCalcAmts[i], ssgenOutScript)
msgTx.AddTxOut(txOut)
}
// Check to make sure our SSGen was created correctly.
_, err = stake.IsSSGen(msgTx)
if err != nil {
return nil, err
}
// Sign the transaction.
err = s.SignVRTransaction(waddrmgrNs, msgTx, sstx, true)
if err != nil {
return nil, err
}
// Store the information about the SSGen.
hash := msgTx.TxSha()
err = s.insertSSGen(ns,
blockHash,
height,
&hash,
voteBits.Bits,
sstx.Sha())
if err != nil {
return nil, err
}
// Send the transaction.
ssgenSha, err := s.chainSvr.SendRawTransaction(msgTx, allowHighFees)
if err != nil {
return nil, err
}
log.Debugf("Generated SSGen %v, voting on block %v at height %v. "+
"The ticket used to generate the SSGen was %v.",
ssgenSha, blockHash, height, sstxHash)
// Generate a notification to return.
ntfn := &StakeNotification{
TxType: int8(stake.TxTypeSSGen),
TxHash: *ssgenSha,
BlockHash: *blockHash,
Height: int32(height),
Amount: 0,
SStxIn: *sstx.Sha(),
VoteBits: voteBits.Bits,
}
return ntfn, nil
}
// GenerateRevocation generates a revocation (SSRtx), signs it, and
// submits it by SendRawTransaction. It also stores a record of it
// in the local database.
func (s *StakeStore) generateRevocation(ns walletdb.ReadWriteBucket, waddrmgrNs walletdb.ReadBucket, blockHash *chainhash.Hash, height int64, sstxHash *chainhash.Hash,
allowHighFees bool) (*StakeNotification, error) {
// 1. Fetch the SStx, then calculate all the values we'll need later for
// the generation of the SSRtx tx outputs.
sstxRecord, err := s.getSStx(ns, sstxHash)
if err != nil {
return nil, err
}
sstx := sstxRecord.tx
// Store the sstx pubkeyhashes and amounts as found in the transaction
// outputs.
// TODO Get information on the allowable fee range for the revocation
// and check to make sure we don't overflow that.
sstxPayTypes, sstxPkhs, sstxAmts, _, _, _ :=
stake.TxSStxStakeOutputInfo(sstx.MsgTx())
ssrtxCalcAmts := stake.CalculateRewards(sstxAmts, sstx.MsgTx().TxOut[0].Value,
int64(0))
// Calculate the fee to use for this revocation based on the fee
// per KB that is standard for mainnet.
revocationSizeEst := estimateSSRtxTxSize(1, len(sstxPkhs))
revocationFee := txrules.FeeForSerializeSize(revocationFeePerKB,
revocationSizeEst)
// 2. Add the only input.
msgTx := wire.NewMsgTx()
// SStx tagged output as an OutPoint; reference this as
// the only input.
prevOut := wire.NewOutPoint(sstxHash,
0, // Index 0
1) // Tree stake
txIn := wire.NewTxIn(prevOut, []byte{})
msgTx.AddTxIn(txIn)
// 3. Add all the OP_SSRTX tagged outputs.
// Add all the SSRtx-tagged transaction outputs to the transaction after
// performing some validity checks.
feeAdded := false
for i, sstxPkh := range sstxPkhs {
// Create a new script which pays to the provided address specified in
// the original ticket tx.
var ssrtxOutScript []byte
switch sstxPayTypes[i] {
case false: // P2PKH
ssrtxOutScript, err = txscript.PayToSSRtxPKHDirect(sstxPkh)
if err != nil {
return nil, err
}
case true: // P2SH
ssrtxOutScript, err = txscript.PayToSSRtxSHDirect(sstxPkh)
if err != nil {
return nil, err
}
}
// Add a fee from an output that has enough.
amt := ssrtxCalcAmts[i]
if !feeAdded && ssrtxCalcAmts[i] >= int64(revocationFee) {
amt -= int64(revocationFee)
feeAdded = true
}
// Add the txout to our SSRtx tx.
txOut := wire.NewTxOut(amt, ssrtxOutScript)
msgTx.AddTxOut(txOut)
}
// Check to make sure our SSRtx was created correctly.
_, err = stake.IsSSRtx(msgTx)
if err != nil {
return nil, err
}
// Sign the transaction.
err = s.SignVRTransaction(waddrmgrNs, msgTx, sstx, false)
if err != nil {
return nil, err
}
// Store the information about the SSRtx.
hash := msgTx.TxSha()
err = s.insertSSRtx(ns,
blockHash,
height,
&hash,
sstx.Sha())
if err != nil {
return nil, err
}
// Send the transaction.
ssrtxSha, err := s.chainSvr.SendRawTransaction(msgTx, allowHighFees)
if err != nil {
return nil, err
}
log.Debugf("Generated SSRtx %v. The ticket used to "+
"generate the SSRtx was %v.", ssrtxSha, sstx.Sha())
// Generate a notification to return.
ntfn := &StakeNotification{
TxType: int8(stake.TxTypeSSRtx),
TxHash: *ssrtxSha,
BlockHash: chainhash.Hash{},
Height: 0,
Amount: 0,
SStxIn: *sstx.Sha(),
VoteBits: 0,
}
return ntfn, nil
}
func Test_dupTx(t *testing.T) {
// Ignore db remove errors since it means we didn't have an old one.
dbname := fmt.Sprintf("tstdbdup0")
dbnamever := dbname + ".ver"
_ = os.RemoveAll(dbname)
_ = os.RemoveAll(dbnamever)
db, err := database.CreateDB("leveldb", dbname)
if err != nil {
t.Errorf("Failed to open test database %v", err)
return
}
defer os.RemoveAll(dbname)
defer os.RemoveAll(dbnamever)
defer func() {
if err := db.Close(); err != nil {
t.Errorf("Close: unexpected error: %v", err)
}
}()
testdatafile := filepath.Join("../", "../blockchain/testdata", "blocks0to168.bz2")
blocks, err := loadBlocks(t, testdatafile)
if err != nil {
t.Errorf("Unable to load blocks from test data for: %v",
err)
return
}
var lastSha *chainhash.Hash
// Populate with the fisrt 256 blocks, so we have blocks to 'mess with'
err = nil
out:
for height := int64(0); height < int64(len(blocks)); height++ {
block := blocks[height]
if height != 0 {
// except for NoVerify which does not allow lookups check inputs
mblock := block.MsgBlock()
//t.Errorf("%v", blockchain.DebugBlockString(block))
parentBlock := blocks[height-1]
mParentBlock := parentBlock.MsgBlock()
var txneededList []*chainhash.Hash
opSpentInBlock := make(map[wire.OutPoint]struct{})
if dcrutil.IsFlagSet16(dcrutil.BlockValid, mParentBlock.Header.VoteBits) {
for _, tx := range mParentBlock.Transactions {
for _, txin := range tx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v (height %v)", origintxsha, height)
}
_, err = db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
}
for _, stx := range mblock.STransactions {
for _, txin := range stx.TxIn {
if txin.PreviousOutPoint.Index == uint32(4294967295) {
continue
}
if existsInOwnBlockRegTree(mParentBlock, txin.PreviousOutPoint.Hash) {
_, used := opSpentInBlock[txin.PreviousOutPoint]
if !used {
// Origin tx is in the block and so hasn't been
// added yet, continue
opSpentInBlock[txin.PreviousOutPoint] = struct{}{}
continue
} else {
t.Errorf("output ref %v attempted double spend of previously spend output", txin.PreviousOutPoint)
}
}
origintxsha := &txin.PreviousOutPoint.Hash
txneededList = append(txneededList, origintxsha)
exists, err := db.ExistsTxSha(origintxsha)
if err != nil {
t.Errorf("ExistsTxSha: unexpected error %v ", err)
}
if !exists {
t.Errorf("referenced tx not found %v", origintxsha)
}
_, err = db.FetchTxBySha(origintxsha)
if err != nil {
t.Errorf("referenced tx not found %v err %v ", origintxsha, err)
}
}
}
txlist := db.FetchUnSpentTxByShaList(txneededList)
for _, txe := range txlist {
if txe.Err != nil {
t.Errorf("tx list fetch failed %v err %v ", txe.Sha, txe.Err)
break out
}
}
}
newheight, err := db.InsertBlock(block)
if err != nil {
t.Errorf("failed to insert block %v err %v", height, err)
break out
}
if newheight != height {
t.Errorf("height mismatch expect %v returned %v", height, newheight)
break out
}
newSha, blkid, err := db.NewestSha()
if err != nil {
t.Errorf("failed to obtain latest sha %v %v", height, err)
}
if blkid != height {
t.Errorf("height doe not match latest block height %v %v %v", blkid, height, err)
}
blkSha := block.Sha()
if *newSha != *blkSha {
t.Errorf("Newest block sha does not match freshly inserted one %v %v %v ", newSha, blkSha, err)
}
lastSha = blkSha
}
// generate a new block based on the last sha
// these block are not verified, so there are a bunch of garbage fields
// in the 'generated' block.
var bh wire.BlockHeader
bh.Version = 0
bh.PrevBlock = *lastSha
// Bits, Nonce are not filled in
mblk := wire.NewMsgBlock(&bh)
hash, _ := chainhash.NewHashFromStr("c23953c56cb2ef8e4698e3ed3b0fc4c837754d3cd16485192d893e35f32626b4")
po := wire.NewOutPoint(hash, 0, dcrutil.TxTreeRegular)
txI := wire.NewTxIn(po, []byte("garbage"))
txO := wire.NewTxOut(50000000, []byte("garbageout"))
var tx wire.MsgTx
tx.AddTxIn(txI)
tx.AddTxOut(txO)
mblk.AddTransaction(&tx)
blk := dcrutil.NewBlock(mblk)
fetchList := []*chainhash.Hash{hash}
listReply := db.FetchUnSpentTxByShaList(fetchList)
for _, lr := range listReply {
if lr.Err != nil {
t.Errorf("sha %v spent %v err %v\n", lr.Sha,
lr.TxSpent, lr.Err)
}
}
_, err = db.InsertBlock(blk)
if err != nil {
t.Errorf("failed to insert phony block %v", err)
}
// ok, did it 'spend' the tx ?
listReply = db.FetchUnSpentTxByShaList(fetchList)
for _, lr := range listReply {
if lr.Err != nil && lr.Err != database.ErrTxShaMissing {
t.Errorf("sha %v spent %v err %v\n", lr.Sha,
lr.TxSpent, lr.Err)
}
}
txlist := blk.Transactions()
for _, tx := range txlist {
txsha := tx.Sha()
txReply, err := db.FetchTxBySha(txsha)
if err != nil {
t.Errorf("fully spent lookup %v err %v\n", hash, err)
} else {
for _, lr := range txReply {
if lr.Err != nil {
t.Errorf("stx %v spent %v err %v\n", lr.Sha,
lr.TxSpent, lr.Err)
}
}
}
}
err = db.DropAfterBlockBySha(lastSha)
if err != nil {
t.Errorf("failed to drop spending block %v", err)
}
}
func TestFilterBloomMatch(t *testing.T) {
str := "0100000001cd24a3a215761757d2b565994b5f544be8cc7996e7835a0b326" +
"feed9f8a3072802000000016a47304402200d1f455ff952f3fae2f9b3d5c" +
"471371ba9d09789abb5cd80f01c6576c6d760e70220283aaa6e18a043a3b" +
"5d105d6fccaca8edf31b705b75d82488414366ca48bdda60121030e233e9" +
"6e98d98336bd2b3f4ec23aaa3c9b5c9b57de6d408490a9ce36c9d4326fff" +
"fffff0600ca9a3b000000001976a914e6719fd3749c5ed40f193928e8b2a" +
"d0dd163efe588acf82f357a0a0000001976a91468447782004ae8718618f" +
"d752f1d02e285f897d488ac00ca9a3b000000001976a9148d2b19f048851" +
"857afd872acde7ccf93bf16f5d488ac00ca9a3b000000001976a914e5aaf" +
"268a042555daabf1e33030f12f61d663ea088ac00ca9a3b000000001976a" +
"914f02e3cb22c39d3e6e0179241e52f21df097b17ae88ac00ca9a3b00000" +
"0001976a9142ea99ce64965bf8cfb40e8e1b7bf4d2cea89db1988ac00000" +
"000"
strBytes, err := hex.DecodeString(str)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err)
return
}
tx, err := dcrutil.NewTxFromBytes(strBytes)
if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return
}
spendingTxBytes := []byte{0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f,
0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6,
0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27,
0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f,
0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30,
0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce,
0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57,
0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0,
0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c,
0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00,
0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e,
0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27,
0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01,
0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10,
0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9,
0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5,
0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff,
0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf,
0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9,
0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb,
0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b,
0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76,
0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07,
0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0,
0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8,
0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14,
0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51,
0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70,
0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00}
spendingTx, err := dcrutil.NewTxFromBytes(spendingTxBytes)
if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return
}
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr := "b4749f017444b051c44dfd2720e88f314ff94f3dd6d56d40ef65854fcd7fff6b"
sha, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewShaHashFromStr failed: %v\n", err)
return
}
f.AddShaHash(sha)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match sha %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "6bff7fcd4f8565ef406dd5d63d4ff94f318fe82027fd4dc451b04474019f74b4"
shaBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match sha %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "30450220070aca44506c5cef3a16ed519d7c3c39f8aab192c4e1c90d065" +
"f37b8a4af6141022100a8e160b856c2d43d27d8fba71e5aef6405b8643" +
"ac4cb7cb3c462aced7f14711a01"
shaBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match input signature %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "046d11fee51b0e60666d5049a9101a72741df480b96ee26488a4d3466b95" +
"c9a40ac5eeef87e10a5cd336c19a84565f80fa6c547957b7700ff4dfbdefe" +
"76036c339"
shaBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match input pubkey %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "04943fdd508053c75000106d3bc6e2754dbcff19"
shaBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match output address %s", inputStr)
}
if !f.MatchTxAndUpdate(spendingTx) {
t.Errorf("TestFilterBloomMatch spendingTx didn't match output address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "a266436d2965547608b9e15d9032a7b9d64fa431"
shaBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match output address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewShaHashFromStr failed: %v\n", err)
return
}
outpoint := wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
f.AddOutPoint(outpoint)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match outpoint %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "00000009e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewShaHashFromStr failed: %v\n", err)
return
}
f.AddShaHash(sha)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched sha %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "0000006d2965547608b9e15d9032a7b9d64fa431"
shaBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(shaBytes)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "90c122d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewShaHashFromStr failed: %v\n", err)
return
}
outpoint = wire.NewOutPoint(sha, 1, dcrutil.TxTreeRegular)
f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewShaHashFromStr failed: %v\n", err)
return
}
outpoint = wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
}
}
// GenerateRevocation generates a revocation (SSRtx), signs it, and
// submits it by SendRawTransaction. It also stores a record of it
// in the local database.
func (s *StakeStore) generateRevocation(blockHash *chainhash.Hash, height int64,
sstxHash *chainhash.Hash) (*StakeNotification, error) {
var revocationFee int64
switch {
case s.Params == &chaincfg.MainNetParams:
revocationFee = revocationFeeMainNet
case s.Params == &chaincfg.TestNetParams:
revocationFee = revocationFeeTestNet
default:
revocationFee = revocationFeeTestNet
}
// 1. Fetch the SStx, then calculate all the values we'll need later for
// the generation of the SSRtx tx outputs.
sstxRecord, err := s.getSStx(sstxHash)
if err != nil {
return nil, err
}
sstx := sstxRecord.tx
// Store the sstx pubkeyhashes and amounts as found in the transaction
// outputs.
// TODO Get information on the allowable fee range for the revocation
// and check to make sure we don't overflow that.
sstxPayTypes, sstxPkhs, sstxAmts, _, _, _ :=
stake.GetSStxStakeOutputInfo(sstx)
ssrtxCalcAmts := stake.GetStakeRewards(sstxAmts, sstx.MsgTx().TxOut[0].Value,
int64(0))
// 2. Add the only input.
msgTx := wire.NewMsgTx()
// SStx tagged output as an OutPoint; reference this as
// the only input.
prevOut := wire.NewOutPoint(sstxHash,
0, // Index 0
1) // Tree stake
txIn := wire.NewTxIn(prevOut, []byte{})
msgTx.AddTxIn(txIn)
// 3. Add all the OP_SSRTX tagged outputs.
// Add all the SSRtx-tagged transaction outputs to the transaction after
// performing some validity checks.
feeAdded := false
for i, sstxPkh := range sstxPkhs {
// Create a new script which pays to the provided address specified in
// the original ticket tx.
var ssrtxOutScript []byte
switch sstxPayTypes[i] {
case false: // P2PKH
ssrtxOutScript, err = txscript.PayToSSRtxPKHDirect(sstxPkh)
if err != nil {
return nil, err
}
case true: // P2SH
ssrtxOutScript, err = txscript.PayToSSRtxSHDirect(sstxPkh)
if err != nil {
return nil, err
}
}
// Add a fee from an output that has enough.
amt := ssrtxCalcAmts[i]
if !feeAdded && ssrtxCalcAmts[i] >= revocationFee {
amt -= revocationFee
feeAdded = true
}
// Add the txout to our SSRtx tx.
txOut := wire.NewTxOut(amt, ssrtxOutScript)
msgTx.AddTxOut(txOut)
}
// Check to make sure our SSRtx was created correctly.
ssrtxTx := dcrutil.NewTx(msgTx)
ssrtxTx.SetTree(dcrutil.TxTreeStake)
_, err = stake.IsSSRtx(ssrtxTx)
if err != nil {
return nil, err
}
// Sign the transaction.
err = s.SignVRTransaction(msgTx, sstx, false)
if err != nil {
return nil, err
}
// Send the transaction.
ssrtxSha, err := s.chainSvr.SendRawTransaction(msgTx, false)
if err != nil {
return nil, err
}
// Store the information about the SSRtx.
err = s.insertSSRtx(blockHash,
height,
ssrtxSha,
sstx.Sha())
if err != nil {
return nil, err
}
log.Debugf("Generated SSRtx %v. "+
"The ticket used to generate the SSRtx was %v.",
ssrtxSha, sstx.Sha())
// Generate a notification to return.
ntfn := &StakeNotification{
TxType: int8(stake.TxTypeSSRtx),
TxHash: *ssrtxSha,
BlockHash: chainhash.Hash{},
Height: 0,
Amount: 0,
SStxIn: *sstx.Sha(),
VoteBits: 0,
}
return ntfn, nil
}
// TestTx tests the MsgTx API.
func TestTx(t *testing.T) {
pver := wire.ProtocolVersion
// Block 100000 hash.
hashStr := "3ba27aa200b1cecaad478d2b00432346c3f1f3986da1afd33e506"
hash, err := chainhash.NewHashFromStr(hashStr)
if err != nil {
t.Errorf("NewShaHashFromStr: %v", err)
}
// Ensure the command is expected value.
wantCmd := "tx"
msg := wire.NewMsgTx()
if cmd := msg.Command(); cmd != wantCmd {
t.Errorf("NewMsgAddr: wrong command - got %v want %v",
cmd, wantCmd)
}
// Ensure max payload is expected value for latest protocol version.
// Num addresses (varInt) + max allowed addresses.
wantPayload := uint32(1000 * 1000)
maxPayload := msg.MaxPayloadLength(pver)
if maxPayload != wantPayload {
t.Errorf("MaxPayloadLength: wrong max payload length for "+
"protocol version %d - got %v, want %v", pver,
maxPayload, wantPayload)
}
// Ensure we get the same transaction output point data back out.
// NOTE: This is a block hash and made up index, but we're only
// testing package functionality.
prevOutIndex := uint32(1)
prevOut := wire.NewOutPoint(hash, prevOutIndex, dcrutil.TxTreeRegular)
if !prevOut.Hash.IsEqual(hash) {
t.Errorf("NewOutPoint: wrong hash - got %v, want %v",
spew.Sprint(&prevOut.Hash), spew.Sprint(hash))
}
if prevOut.Index != prevOutIndex {
t.Errorf("NewOutPoint: wrong index - got %v, want %v",
prevOut.Index, prevOutIndex)
}
prevOutStr := fmt.Sprintf("%s:%d", hash.String(), prevOutIndex)
if s := prevOut.String(); s != prevOutStr {
t.Errorf("OutPoint.String: unexpected result - got %v, "+
"want %v", s, prevOutStr)
}
// Ensure we get the same transaction input back out.
sigScript := []byte{0x04, 0x31, 0xdc, 0x00, 0x1b, 0x01, 0x62}
txIn := wire.NewTxIn(prevOut, sigScript)
if !reflect.DeepEqual(&txIn.PreviousOutPoint, prevOut) {
t.Errorf("NewTxIn: wrong prev outpoint - got %v, want %v",
spew.Sprint(&txIn.PreviousOutPoint),
spew.Sprint(prevOut))
}
if !bytes.Equal(txIn.SignatureScript, sigScript) {
t.Errorf("NewTxIn: wrong signature script - got %v, want %v",
spew.Sdump(txIn.SignatureScript),
spew.Sdump(sigScript))
}
// Ensure we get the same transaction output back out.
txValue := int64(5000000000)
pkScript := []byte{
0x41, // OP_DATA_65
0x04, 0xd6, 0x4b, 0xdf, 0xd0, 0x9e, 0xb1, 0xc5,
0xfe, 0x29, 0x5a, 0xbd, 0xeb, 0x1d, 0xca, 0x42,
0x81, 0xbe, 0x98, 0x8e, 0x2d, 0xa0, 0xb6, 0xc1,
0xc6, 0xa5, 0x9d, 0xc2, 0x26, 0xc2, 0x86, 0x24,
0xe1, 0x81, 0x75, 0xe8, 0x51, 0xc9, 0x6b, 0x97,
0x3d, 0x81, 0xb0, 0x1c, 0xc3, 0x1f, 0x04, 0x78,
0x34, 0xbc, 0x06, 0xd6, 0xd6, 0xed, 0xf6, 0x20,
0xd1, 0x84, 0x24, 0x1a, 0x6a, 0xed, 0x8b, 0x63,
0xa6, // 65-byte signature
0xac, // OP_CHECKSIG
}
txOut := wire.NewTxOut(txValue, pkScript)
if txOut.Value != txValue {
t.Errorf("NewTxOut: wrong pk script - got %v, want %v",
txOut.Value, txValue)
}
if !bytes.Equal(txOut.PkScript, pkScript) {
t.Errorf("NewTxOut: wrong pk script - got %v, want %v",
spew.Sdump(txOut.PkScript),
spew.Sdump(pkScript))
}
// Ensure transaction inputs are added properly.
msg.AddTxIn(txIn)
if !reflect.DeepEqual(msg.TxIn[0], txIn) {
t.Errorf("AddTxIn: wrong transaction input added - got %v, want %v",
spew.Sprint(msg.TxIn[0]), spew.Sprint(txIn))
}
// Ensure transaction outputs are added properly.
msg.AddTxOut(txOut)
if !reflect.DeepEqual(msg.TxOut[0], txOut) {
t.Errorf("AddTxIn: wrong transaction output added - got %v, want %v",
spew.Sprint(msg.TxOut[0]), spew.Sprint(txOut))
}
// Ensure the copy produced an identical transaction message.
newMsg := msg.Copy()
if !reflect.DeepEqual(newMsg, msg) {
t.Errorf("Copy: mismatched tx messages - got %v, want %v",
spew.Sdump(newMsg), spew.Sdump(msg))
}
return
}
// TestTxValidTests ensures all of the tests in tx_valid.json pass as expected.
func TestTxValidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/tx_valid.json")
if err != nil {
t.Errorf("TestTxValidTests: %v\n", err)
return
}
var tests [][]interface{}
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestTxValidTests couldn't Unmarshal: %v\n", err)
return
}
// form is either:
// ["this is a comment "]
// or:
// [[[previous hash, previous index, previous scriptPubKey]...,]
// serializedTransaction, verifyFlags]
testloop:
for i, test := range tests {
inputs, ok := test[0].([]interface{})
if !ok {
continue
}
if len(test) != 3 {
t.Errorf("bad test (bad length) %d: %v", i, test)
continue
}
serializedhex, ok := test[1].(string)
if !ok {
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
continue
}
serializedTx, err := hex.DecodeString(serializedhex)
if err != nil {
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
test)
continue
}
tx, err := dcrutil.NewTxFromBytesLegacy(serializedTx)
if err != nil {
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
i, test)
continue
}
verifyFlags, ok := test[2].(string)
if !ok {
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
continue
}
flags, err := parseScriptFlags(verifyFlags)
if err != nil {
t.Errorf("bad test %d: %v", i, err)
continue
}
prevOuts := make(map[wire.OutPoint][]byte)
for j, iinput := range inputs {
input, ok := iinput.([]interface{})
if !ok {
t.Errorf("bad test (%dth input not array)"+
"%d: %v", j, i, test)
continue
}
if len(input) != 3 {
t.Errorf("bad test (%dth input wrong length)"+
"%d: %v", j, i, test)
continue
}
previoustx, ok := input[0].(string)
if !ok {
t.Errorf("bad test (%dth input sha not string)"+
"%d: %v", j, i, test)
continue
}
prevhash, err := chainhash.NewHashFromStr(previoustx)
if err != nil {
t.Errorf("bad test (%dth input sha not sha %v)"+
"%d: %v", j, err, i, test)
continue
}
idxf, ok := input[1].(float64)
if !ok {
t.Errorf("bad test (%dth input idx not number)"+
"%d: %v", j, i, test)
continue
}
idx := testVecF64ToUint32(idxf)
oscript, ok := input[2].(string)
if !ok {
t.Errorf("bad test (%dth input script not "+
"string) %d: %v", j, i, test)
continue
}
script, err := parseShortForm(oscript)
if err != nil {
t.Errorf("bad test (%dth input script doesn't "+
"parse %v) %d: %v", j, err, i, test)
continue
}
prevOuts[*wire.NewOutPoint(prevhash, idx, dcrutil.TxTreeRegular)] = script
}
for k, txin := range tx.MsgTx().TxIn {
pkScript, ok := prevOuts[txin.PreviousOutPoint]
if !ok {
t.Errorf("bad test (missing %dth input) %d:%v",
k, i, test)
continue testloop
}
vm, err := NewEngine(pkScript, tx.MsgTx(), k, flags, 0,
nil)
if err != nil {
t.Errorf("test (%d:%v:%d) failed to create "+
"script: %v", i, test, k, err)
continue
}
err = vm.Execute()
if err != nil {
t.Errorf("test (%d:%v:%d) failed to execute: "+
"%v", i, test, k, err)
continue
}
}
}
}
// TestTxInvalidTests ensures all of the tests in tx_invalid.json fail as
// expected.
func TestTxInvalidTests(t *testing.T) {
file, err := ioutil.ReadFile("data/tx_invalid.json")
if err != nil {
t.Errorf("TestBitcoindInvalidTests: %v\n", err)
return
}
var tests [][]interface{}
err = json.Unmarshal(file, &tests)
if err != nil {
t.Errorf("TestBitcoindInvalidTests couldn't Unmarshal: %v\n",
err)
return
}
// form is either:
// ["this is a comment "]
// or:
// [[[previous hash, previous index, previous scriptPubKey]...,]
// serializedTransaction, verifyFlags]
testloop:
for i, test := range tests {
inputs, ok := test[0].([]interface{})
if !ok {
continue
}
if len(test) != 3 {
t.Errorf("bad test (bad length) %d: %v", i, test)
continue
}
serializedhex, ok := test[1].(string)
if !ok {
t.Errorf("bad test (arg 2 not string) %d: %v", i, test)
continue
}
serializedTx, err := hex.DecodeString(serializedhex)
if err != nil {
t.Errorf("bad test (arg 2 not hex %v) %d: %v", err, i,
test)
continue
}
tx, err := dcrutil.NewTxFromBytesLegacy(serializedTx)
if err != nil {
t.Errorf("bad test (arg 2 not msgtx %v) %d: %v", err,
i, test)
continue
}
verifyFlags, ok := test[2].(string)
if !ok {
t.Errorf("bad test (arg 3 not string) %d: %v", i, test)
continue
}
flags, err := parseScriptFlags(verifyFlags)
if err != nil {
t.Errorf("bad test %d: %v", i, err)
continue
}
prevOuts := make(map[wire.OutPoint][]byte)
for j, iinput := range inputs {
input, ok := iinput.([]interface{})
if !ok {
t.Errorf("bad test (%dth input not array)"+
"%d: %v", j, i, test)
continue testloop
}
if len(input) != 3 {
t.Errorf("bad test (%dth input wrong length)"+
"%d: %v", j, i, test)
continue testloop
}
previoustx, ok := input[0].(string)
if !ok {
t.Errorf("bad test (%dth input sha not string)"+
"%d: %v", j, i, test)
continue testloop
}
prevhash, err := chainhash.NewHashFromStr(previoustx)
if err != nil {
t.Errorf("bad test (%dth input sha not sha %v)"+
"%d: %v", j, err, i, test)
continue testloop
}
idxf, ok := input[1].(float64)
if !ok {
t.Errorf("bad test (%dth input idx not number)"+
"%d: %v", j, i, test)
continue testloop
}
idx := uint32(idxf) // (floor(idxf) == idxf?)
oscript, ok := input[2].(string)
if !ok {
t.Errorf("bad test (%dth input script not "+
"string) %d: %v", j, i, test)
continue testloop
}
script, err := parseShortForm(oscript)
if err != nil {
t.Errorf("bad test (%dth input script doesn't "+
"parse %v) %d: %v", j, err, i, test)
continue testloop
}
prevOuts[*wire.NewOutPoint(prevhash, idx, dcrutil.TxTreeRegular)] = script
}
for k, txin := range tx.MsgTx().TxIn {
pkScript, ok := prevOuts[txin.PreviousOutPoint]
if !ok {
t.Errorf("bad test (missing %dth input) %d:%v",
k, i, test)
continue testloop
}
// These are meant to fail, so as soon as the first
// input fails the transaction has failed. (some of the
// test txns have good inputs, too..
vm, err := NewEngine(pkScript, tx.MsgTx(), k, flags, 0)
if err != nil {
continue testloop
}
err = vm.Execute()
if err != nil {
continue testloop
}
}
t.Errorf("test (%d:%v) succeeded when should fail",
i, test)
}
}
func TestFilterInsertP2PubKeyOnly(t *testing.T) {
blockStr := "000000004ad131bae9cb9f74b8bcd928" +
"a60dfe4dadabeb31b1e79403385f9ac4" +
"ccc28b7400429e56f7df2872aaaa0c16" +
"221cb09059bd3ea897de156ff51202ff" +
"72b2cd8d000000000000000000000000" +
"00000000000000000000000000000000" +
"00000000010000000000000000000000" +
"22000000ffff7f20002d310100000000" +
"640000007601000063a0815601000000" +
"00000000000000000000000000000000" +
"00000000000000000000000000000000" +
"00000000010100000001000000000000" +
"00000000000000000000000000000000" +
"00000000000000000000ffffffff00ff" +
"ffffff0380b2e60e00000000000017a9" +
"144fa6cbd0dbe5ec407fe4c8ad374e66" +
"7771fa0d448700000000000000000000" +
"226a2000000000000000000000000000" +
"0000009e0453a6ab10610e17a7a5fadc" +
"f6c34f002f68590000000000001976a9" +
"141b79e6496226f89ad4e049667c1344" +
"c16a75815188ac000000000000000001" +
"000000000000000000000000ffffffff" +
"04deadbeef00"
blockBytes, err := hex.DecodeString(blockStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
block, err := dcrutil.NewBlockFromBytes(blockBytes)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly NewBlockFromBytes failed: %v", err)
return
}
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateP2PubkeyOnly)
// Generation pubkey
inputStr := "04eaafc2314def4ca98ac970241bcab022b9c1e1f4ea423a20f134c" +
"876f2c01ec0f0dd5b2e86e7168cefe0d81113c3807420ce13ad1357231a" +
"2252247d97a46a91"
inputBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Output address of 4th transaction
inputStr = "b6efd80d99179f4f4ff6f4dd0a007d018c385d21"
inputBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Ignore return value -- this is just used to update the filter.
_, _ = bloom.NewMerkleBlock(block, f)
// We should match the generation pubkey
inputStr = "147caa76786596590baa4e98f5d9f48b86c7765e489f7a6ff3360fe5c674360b"
sha, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewShaHashFromStr failed: %v", err)
return
}
outpoint := wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
if !f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly didn't match the generation "+
"outpoint %s", inputStr)
return
}
// We should not match the 4th transaction, which is not p2pk
inputStr = "02981fa052f0481dbc5868f4fc2166035a10f27a03cfd2de67326471df5bc041"
sha, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewShaHashFromStr failed: %v", err)
return
}
outpoint = wire.NewOutPoint(sha, 0, dcrutil.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly matched outpoint %s", inputStr)
return
}
}
func TestFilterInsertP2PubKeyOnly(t *testing.T) {
blockStr := "000000003ffad804971ce6b8a13c8162287222d91395fa77b6bea6b4" +
"626b4827000000004259bd8a4d5d5f8469f390903d27b9cab2ea03822fbe" +
"616478756ada751a283be8e4aa58eeb75810e22031cc2756442b7f68c77b" +
"3735522fc5490be1676253c301005f031703bb61050000005c1300006fb2" +
"381c30dd35680000000091940000fc0900000cadf15600d9781d3a5f237b" +
"083799410f00000000000000000000000000000000000000000000000000" +
"000002010000000100000000000000000000000000000000000000000000" +
"00000000000000000000ffffffff00ffffffff032727750c000000000000" +
"17a9144fa6cbd0dbe5ec407fe4c8ad374e667771fa0d4487000000000000" +
"00000000266a249194000000000000000000000000000000000000000000" +
"0000000000b90c53023ee736e6d7eebe4a0000000000001976a914bfe0f6" +
"3eda5d7db3ee05661051c026f5296ffc7888ac0000000000000000011512" +
"34570000000000000000ffffffff0800002f646372642f01000000020c57" +
"441e66eaa72bc76ab54faaa0ec87941f4423a463c5e34d7f23f247d65e9d" +
"0200000001ffffffff31b7ffaec935e787dc03670d4d13ee0066717cb750" +
"2cb4d925b09b7f692a73580400000001ffffffff0200ca9a3b0000000000" +
"0023210351b64c01163b9184637671e27d6d29b3a205203710f6fbc5a6e1" +
"b646a11984d6ac81001f060000000000001976a9144feba3e04d91d9dc90" +
"ebb13ce91bf9bcfe32ff9288ac000000000000000002c29f493300000000" +
"8f9400000a0000006a4730440220186741de60d6fe75d2206b62780edabe" +
"8a0a13f823aaeca58f0d5a8dedfa99f202201dc84a1bd26d14723ddf2fe4" +
"216d4a24d788597fa22255d144ce119d7544ce39012103879a3b3666bf03" +
"88ab33e6e24e77c3c219044f7c5d778b71ac1837817095830da72e700e00" +
"000000909400000e0000006b4830450221008cc441f58be0eedc713b867d" +
"c8dfff21e2f6c2e38a906a0af5aa0625b2683f6b0220308bcaf6628b3c68" +
"19da76ebb2ca5e5d1ddde6e5035193d75e3e667731deadc4012102a871fe" +
"4e4f77121f1cbaf2db62190539687092b465e252a3bd732791ca442d5405" +
"010000000200000000000000000000000000000000000000000000000000" +
"00000000000000ffffffff00ffffffff91ed802c4a23cca0517dbc2d89f7" +
"b6f8a2d1491a27ed25e3d3f621bac03316da0000000001ffffffff030000" +
"0000000000000000266a243ffad804971ce6b8a13c8162287222d91395fa" +
"77b6bea6b4626b4827000000009094000000000000000000000000046a02" +
"010003d0db190100000000001abb76a914339f1f6a41d7ef65ffd80bbb8c" +
"daaa215a16472d88ac000000000000000002e47d79070000000000000000" +
"ffffffff04deadbeef1f52621201000000938b0000090000006a47304402" +
"207184b4d7a95a559b1142f50cfde3e40bf460572aea4d5eeabad062e45c" +
"9a8f5102202304acbcc9cc55e58770e51d4fc9ac81af9c790a65d251ea4d" +
"556bc7ee96fb47012103c46bdbf6b24be97eac230ca9b23e928e2e76750d" +
"3d3c8b29e15cebb64ba01f86010000000200000000000000000000000000" +
"00000000000000000000000000000000000000ffffffff00ffffffff17be" +
"9d003549030c20c018a71745af6f6a02d96637f49f5a548ee7fe0ac84420" +
"0000000001ffffffff0300000000000000000000266a243ffad804971ce6" +
"b8a13c8162287222d91395fa77b6bea6b4626b4827000000009094000000" +
"000000000000000000046a02010071c339cf0000000000001abb76a9147f" +
"1aaac9f04febbf9dadd262b1c710729970445988ac000000000000000002" +
"e47d79070000000000000000ffffffff04deadbeef8d45c0c70000000099" +
"8f0000070000006a473044022054a09af013f1a74960686bf5c36f3eb822" +
"5ffc96e76a54dc1aac9fdea65cff2b022010359dfcd16ac77f3a6ab47309" +
"e106a885fa2d031d5bac0824f4432a77ccdae001210389e445603d66ce44" +
"92ec74d9b1974268a2e83413c84df87895184bc6f46ae1d7010000000200" +
"000000000000000000000000000000000000000000000000000000000000" +
"00ffffffff00ffffffff49a883465f82c0483b3ff7da057cab44a42ecbc8" +
"27c344a960a2a33c95263f760000000001ffffffff030000000000000000" +
"0000266a243ffad804971ce6b8a13c8162287222d91395fa77b6bea6b462" +
"6b4827000000009094000000000000000000000000046a0201002c9d63bf" +
"0000000000001abb76a91449d402e31fc08414f565febaa1b69eccc2fb8d" +
"2688ac000000000000000002e47d79070000000000000000ffffffff04de" +
"adbeef481feab70000000064870000120000006a473044022008daa49081" +
"d7dc6c466a4d3fd4184927e8b77fd1f5721f206bf0d13a2c00b07802202d" +
"89841ad5346de14db95c3e5b15a0d82e0df1f50a235f67aeec08b98f4b36" +
"7a012102907261a4670a9d0ff918724af50f2ecb7947831dad30ac285afa" +
"1b90549aa282010000000200000000000000000000000000000000000000" +
"00000000000000000000000000ffffffff00ffffffffb6df4ea74c958f39" +
"65ecc90b9226cfdc2d7986b1df30998cf3e827d7e9fbf4b80000000001ff" +
"ffffff0300000000000000000000266a243ffad804971ce6b8a13c816228" +
"7222d91395fa77b6bea6b4626b4827000000009094000000000000000000" +
"000000046a020100f3a613b90000000000001abb76a9147f9321c65ee805" +
"d87f67b0b0e9dac4f0779c1d3a88ac000000000000000002e47d79070000" +
"000000000000ffffffff04deadbeef0f299ab100000000408d0000130000" +
"006b4830450221008c5759dd9f0c40c61f61f5b67c0b3f860d4d59859fb2" +
"451dbeab9956b3ceb05602203e81d5b88b83e279dc7feca13c8e5eb58676" +
"158243058ec43d6366933397be4a0121031e6757ee86e94a02e567db7d4e" +
"c4ba5088f6b5fdbfe9b2794b70b42b52b879200100000002000000000000" +
"0000000000000000000000000000000000000000000000000000ffffffff" +
"00ffffffff9e74ead771c313f0c0bb739860eba39d04a8cce201cda626dc" +
"6a7dd4e83b3f770000000001ffffffff0400000000000000000000266a24" +
"3ffad804971ce6b8a13c8162287222d91395fa77b6bea6b4626b48270000" +
"00009094000000000000000000000000046a0201000793a0e00000000000" +
"001abb76a914c8c5a2cbd183871718dcb14b5f198561450d157e88ac596e" +
"8f250000000000001abb76a9147112f7d015baeb129e732b9c4805e492ef" +
"d0a2fb88ac000000000000000002e47d79070000000000000000ffffffff" +
"04deadbeef7d83b6fe0000000022920000070000006a4730440220160ff7" +
"bd84190d8d837ac6bd782be475d23d50832872626453bd70ea63d9a6a002" +
"20603afdd51fc8e3fead1fd9dbae410b8d0617969ad5119e6dc2b0855d7b" +
"48e73501210297ab850cae270e9438693353e40444c7e714e179505e8b12" +
"1c042f4869e42072"
blockBytes, err := hex.DecodeString(blockStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
block, err := dcrutil.NewBlockFromBytes(blockBytes)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly NewBlockFromBytes failed: %v", err)
return
}
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateP2PubkeyOnly)
// Generation pubkey
inputStr := "0351b64c01163b9184637671e27d6d29b3a205203710f6fbc5a6e1b646a11984d6"
inputBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Output address of 2nd transaction
inputStr = "4feba3e04d91d9dc90ebb13ce91bf9bcfe32ff92"
inputBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterInsertP2PubKeyOnly DecodeString failed: %v", err)
return
}
f.Add(inputBytes)
// Ignore return value -- this is just used to update the filter.
_, _ = bloom.NewMerkleBlock(block, f)
// We should match the generation pubkey
inputStr = "8199f30ccc006056ed79cf0a3cd0b67a195ffd46903d42adc7babe2ed2f2e371"
hash, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err)
return
}
outpoint := wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
if !f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly didn't match the generation "+
"outpoint %s", inputStr)
return
}
// We should not match the 4th transaction, which is not p2pk
inputStr = "d7314aaf54253c651e8258c7d22c574af8804611f0dcea79fd9a47f4565d85ad"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestMerkleBlockP2PubKeyOnly NewHashFromStr failed: %v", err)
return
}
outpoint = wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
if f.MatchesOutPoint(outpoint) {
t.Errorf("TestMerkleBlockP2PubKeyOnly matched outpoint %s", inputStr)
return
}
}
func TestFilterBloomMatch(t *testing.T) {
// tx 2 from blk 10000
str := "0100000001a4fbbbca2416ba4c10c94be9f4a650d37fc4f9a1a4ecded9cc2" +
"714aa0a529a750000000000ffffffff02c2d0b32f0000000000001976a91" +
"499678d10a90c8df40e4c9af742aa6ebc7764a60e88acbe01611c0000000" +
"000001976a9147701528df10cf0c14f9e53925031bd398796c1f988ac000" +
"000000000000001e0b52b4c0000000003270000020000006b48304502210" +
"08003ce072e4b67f9a98129ac2f58e3de6e06f47a15e248d4375d19dfb52" +
"7a02d02204ab0a0dfe7c69024ae8e524e01d1c45183efda945a0d411e4e9" +
"4b69be21efbe601210270c906c3ba64ba5eb3943cc012a3b142ef169f066" +
"002515bf9ec1bd9b7e27f0d"
strBytes, err := hex.DecodeString(str)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err)
return
}
tx, err := dcrutil.NewTxFromBytes(strBytes)
if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return
}
spendingStr := "01000000018c5e1f62f83d750a0ee228c228731eae241e6b483e5b63be199" +
"12846eb2d11500000000000ffffffff02ed44871d0000000000001976a91" +
"461788151a27fad1a9c609fa29a2bd43886e2dd4088ac75a815120000000" +
"000001976a91483419547ee3db5c0ee29f347740ff7f448e8ab2c88ac000" +
"000000000000001c2d0b32f0000000010270000010000006b48304502210" +
"0aca38b780893b6be3287efa908ace8bb8b91af0477ab433f101889b86bb" +
"d9c2d0220789a177956f91c75141ea527573294a20f6fc0ea8bd5cc33550" +
"4a0654ae197e30121025516815b900e10e51824ea1f451fd197fb11209af" +
"60c5c52f9a8cf3edad5dc09"
spendingTxBytes, err := hex.DecodeString(spendingStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failure: %v", err)
return
}
spendingTx, err := dcrutil.NewTxFromBytes(spendingTxBytes)
if err != nil {
t.Errorf("TestFilterBloomMatch NewTxFromBytes failure: %v", err)
return
}
f := bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr := "50112deb46289119be635b3e486b1e24ae1e7328c228e20e0a753df8621f5e8c"
hash, err := chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return
}
f.AddHash(hash)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match hash %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "8c5e1f62f83d750a0ee228c228731eae241e6b483e5b63be19912846eb2d1150"
hashBytes, err := hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match hash %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "30450221008003ce072e4b67f9a98129ac2f58e3de6e06f47a15e248d43" +
"75d19dfb527a02d02204ab0a0dfe7c69024ae8e524e01d1c45183efda945a0" +
"d411e4e94b69be21efbe601"
hashBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match input signature %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "0270c906c3ba64ba5eb3943cc012a3b142ef169f066002515bf9ec1bd9b7e27f0d"
hashBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match input pubkey %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "99678d10a90c8df40e4c9af742aa6ebc7764a60e"
hashBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match output address %s", inputStr)
}
if !f.MatchTxAndUpdate(spendingTx) {
t.Errorf("TestFilterBloomMatch spendingTx didn't match output address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "7701528df10cf0c14f9e53925031bd398796c1f9"
hashBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match output address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "759a520aaa1427ccd9deeca4a1f9c47fd350a6f4e94bc9104cba1624cabbfba4"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return
}
outpoint := wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
f.AddOutPoint(outpoint)
if !f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch didn't match outpoint %s", inputStr)
}
// XXX unchanged from btcd
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "00000009e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return
}
f.AddHash(hash)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched hash %s", inputStr)
}
// XXX unchanged from btcd
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "0000006d2965547608b9e15d9032a7b9d64fa431"
hashBytes, err = hex.DecodeString(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch DecodeString failed: %v\n", err)
return
}
f.Add(hashBytes)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched address %s", inputStr)
}
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "759a520aaa1427ccd9deeca4a1f9c47fd350a6f4e94bc9104cba1624cabbfba4"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return
}
outpoint = wire.NewOutPoint(hash, 1, wire.TxTreeRegular)
f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
}
// XXX unchanged from btcd
f = bloom.NewFilter(10, 0, 0.000001, wire.BloomUpdateAll)
inputStr = "000000d70786e899529d71dbeba91ba216982fb6ba58f3bdaab65e73b7e9260b"
hash, err = chainhash.NewHashFromStr(inputStr)
if err != nil {
t.Errorf("TestFilterBloomMatch NewHashFromStr failed: %v\n", err)
return
}
outpoint = wire.NewOutPoint(hash, 0, wire.TxTreeRegular)
f.AddOutPoint(outpoint)
if f.MatchTxAndUpdate(tx) {
t.Errorf("TestFilterBloomMatch matched outpoint %s", inputStr)
}
}