seedhammer/dcrd
seedhammer/dcrd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
bad849b69d
dcrd/txscript/sign_test.go
Marco Peereboom 80f5feb1db
multi: Add decentralized treasury support. 
This is based on https://proposals.decred.org/proposals/c96290a but was
modified in order to deal with realities that were unknown at the time
of the specification draft.

It is large and could not really be broken apart due to the pervasive
use of the isTreasuryEnabled flag. It was primarily authored by
* Marco Peereboom <marco@peereboom.us>
* Dave Collins <davec@conformal.com>
* Matheus Degiovani <opensource@matheusd.com>

With additional contributions from
* Donald Adu-Poku <donald.adu@gmail.com>
* Jamie Holdstock <jholdstock@decred.org>

Major changes:
* Add decentralized treasury agenda, as specified in DCP0006, to all supported
  nets.
* Add functions to determine if the decentralized treasury agenda is active at
  given block.
* Add new opcode OP_TADD that is a nop in txscript but is used to tag scripts
  that credit the treasury account. This opcode is overloaded for treasurybase
  and for normal transactions.
* Add new opcode OP_TSPEND that is a nop in txscript but is used to tag scripts
  that debit the treasury account.
* Add new opcode OP_TGEN that is a nop in txscript but is used to tag P2PKH and
  P2SH outputs in a TSpend transaction.
* Add functions that detect if a transaction is a valid TAdd, TSpend
  or treasurybase transaction.
* Add error codes that return specific treasurybase/TAdd/TSpend consensus
  violations.
* Modify countSpentOutputs to deal with treasury opcodes accordingly.
* Modify indexBlock to skip treasury transactions that do not have inputs.
* Add IsTreasuryEnabled call to ChainQueryer interface.
* Add treasury logger for debugging and logging the decentralized treasury
  subsystem.
* Add IsTreasuryActive flag to BlockConnectedNtfnsData and
  BlockDisconnectedNtfnsData.
* Modify OP_SSGEN to allow an optional output that contains votes for a TSpend
  transaction hash.
* Add function that returns TSpend votes from an SSGen transaction.
* Modify CalcStakeVoteSubsidy so that treasurybase, unlike coinbase, is always
  awarded the full percentage of the assigned block reward.
* Add helper functions to do all TSpend math so that callers don't roll their
  own.
* Modify IsCoinBaseTx to not mistake a TSpend transaction as a coinbase.
* Add checkTreasuryBase function that verifies that a treasurybase is properly
  constructed and pays the right amount to the treasury account.
* Add functions to calculate treasury balance for the provided block hash/node.
* Add function that verifies if a TSpend has a valid signature.
* Add functions to determine if a TSpend is not overspending.
* Add function to determine if a TSpend has been mined on the provided chain.
* Add functions that count and verifies treasury spend votes.
* Modify connectTransaction and disconnectTransactions to deal with the various
  treasury transactions.
* Split CheckTransactionSanity in two functions
  checkTransactionSanityContextFree and checkTransactionSanityContextual. This
  is done in order to keep the decentralized treasury, which is always
  contextual, from infecting the context free checks.
* Modify checkTransactionSanityContextual to recognize and verify treasury
  transactions.
* Modify CheckTransactionSanity to deal with treasury transactions.
* Split checkBlockSanity in two functions checkBlockSanityContextFree and
  checkBlockSanityContextual. This is done in order to keep the decentralized
  treasury, which is always contextual, from infecting the context free checks.
* Modify checkBlockSanityContextual to enforce treasurybase and TAdd consensus
  checks.
* Modify checkBlockPositional by unindenting it and adding TSpend consensus
  enforcement.
* Modify checkCoinbaseUniqueHeightWithAddress to deal with the removal of the
  project subsidy from output 0.
* Add checkCoinbaseUniqueHeightWithTreasuryBase that verifies coinbase and
  treasurybase in the provided block.
* Unindent checkBlockContext.
* Modify checkTicketRedeemerCommitments and checkVoteInputs to deal with
  potential tspend votes.
* Modify CheckTransactionInputs to skip treasurybase transactions.
* Modify CheckTransactionInputs to deal with TSpend transactions. Ensure the
  provided Pi key is valid and that the signature is valid for the transaction.
  Ensure that treasury TAdd and TSpend transaction utxo can only be spent after
  coinbase maturity.
* Modify CountSigOps to deal with treasury transactions.
* Modify CountP2SHSigOps to deal with treasury transactions.
* Modify getStakeTreeFees to skip treasury transactions. Modify
  totalOutputs to subtract ValueIn 0 for TSpend and treasurybase transactions.
* Modify checkTransactionsAndConnect to deal with modified amounts.
* Add tspendChecks function that verifies an entire TSpend transaction
  validity at the point of the provided block. It ensures a TSpend is on a TVI.
  It ensures the TSpend is in the valid window. It verifies that a TSpend In
  and Out amounts match. It ensures a TSpend has the ValueIn amount encoded in
  the OP_RETURN in Out 0. It ensures a TSpend has not been mined before on this
  chain. It ensures a TSpend has the requisite votes. It ensures a TSpend is
  not overspending.
* Modify checkConnectBlock to call checkTreasuryBase and tspendChecks when
  treasury agenda is active.
* Add two tables to the database. Table "treasury" records the balance as of
  this block and balance changes that occurred in this block which will become
  active in CoinbaseMaturity blocks. Table "tspend" records all block hashes
  where a TSpend has been mined this is to detect forks and prevent a Tspend
  from being mined more than once.
* Modify handleBlockchainNotification to communicate if the treasury agenda is
  active and skip treasurybase transaction when needed.
* Add various Treasury parameters to chaincfg params.
* Add hardcoded Tspend signatures in dcr_tmux_simnet_setup.sh.
* Add notifytspend and stoptspend calls to the RPC server. notifytspend
  notifies the mempool when a TSpend transaction arrives.
* Modify commit filters V2 to recognize TAdd and TSpend transactions. It was
  possible to modify V2 instead of introducing V3 because nothing changes from
  the viewpoint of the wallet and treasury opcodes are disallowed prior to
  agenda activation.
* Modify AddMemPoolTransaction to skip TSpend transactions that would throw the
  fee estimator off.
* Add IsTreasuryAgendaActive, OnTSpendReceived and TSpendMinedOnAncestor to
  mempool.Config in order to reject/accept TSpends in the mempool.
* Modify checkPoolDoubleSpend to ignore treasurybase.
* Modify mempool.maybeAcceptTransaction to enforce treasury standardness rules.
  Don't allow TSpend transactions prior to stake validation height. Skip
  treasurybase and tspend transactions in the orphan test. Ensure a tspend is
  in a valid window. Ensure not more than 7 TSpends are active in the mempool.
  Ensure TSpend has a well-known Pi key. Ensure The provided Pi key was used to
  sign the transaction. Ensure TSpend was not mined in an ancestor block.
  Notify subscribers that a valid TSpend was received.
* Add standardCoinbaseOpReturn and standardTreasurybaseOpReturn to create an
  OP_RETURN followed by a data push that little endian encodes the height of
  the block. Then there are a number of random bytes to ensure that the
  transaction hash is always random.
* Modify createCoinbaseTx to create a coinbase that is valid when treasury is
  enabled or not. Additionally, alter the transaction version if treasury is
  enabled.
* Add createTreasuryBaseTx that creates a standard treasurybase.
* Modify maybeInsertStakeTx to recognize treasurybase and TSpend transactions.
* Modify handleTooFewVoters to call createTreasuryBaseTx when the treasury
  agenda is active. Skip copying treasurybase.
* Modify NewBlockTemplate to recognize and deal with treasury transactions.
  Skip TSpend transaction if block is not a TVI. Skip TSpend transaction if it
  is not in the proper window. Skip TSpend transaction if a TSpend does not
  have enough yes votes. Skip TSpend transaction if it overspends the treasury
  account. Skip TAdd if there are more than 20 TAdds in the block. Create
  treasurybase if required. Insert valid TAdd/TSpend transactions into stake
  tree.
* Add TreasuryBalance and IsTreasuryAgendaActive to rpcserver Chain interface.
* Add gettreasurybalance, sendfromtreasury and sendtotreasury calls to RPC
  server.
* Add notifytspend and stopnotifytspend to RPC websocket commands.
* Add simnet miner to generate large number of blocks during rpctests without
  triggering PoW difficulty increases. This is used to verify various treasury
  and tspend conditions during CI/CT.
* Modify RPC voting wallet to also vote on TSpends.
* Add json tests to verify all new opcodes and corner cases in the script
  engine.
* Modify isStakeOpcode to recognize treasury opcodes.
* Modify countSigOpsV0 to count TSpends.
* Modify handleStakeOutSign to deal with TSpends.
* Modify SignTxOutput to recognize TSpends.
* Add TSpendSignatureScript that signs a TSpend transaction.
* Add TreasuryAddTy and TreasurySpendTy types to the standard scripts.
* Add isTreasuryAddScript and isTreasurySpendScript functions that recognize
  a form of TAdd and TSpend transactions.
* Modify ExtractPkScriptAddrs to deal with TAdd and TSpend outputs.
* Add TxVersionSeqLock = 2 and TxVersionTreasury = 3 to wire. This is
  used to discriminate between treasury and non-treasury scripts.
* Rig up all functions that need the isTreasuryEnabledflag directly or
  indirectly.
* Shuffle various functions around and export them when they were needed to be
  called from other packages.
* Added and modified numerous tests to verify (hopefully) all corner cases that
  the decentralized treasury agenda has added.
2020-09-21 12:15:31 -05:00

2925 lines
80 KiB
Go
Raw Blame History

// Copyright (c) 2013-2016 The btcsuite developers
// Copyright (c) 2015-2020 The Decred developers
// Use of this source code is governed by an ISC
// license that can be found in the LICENSE file.
package txscript
import (
"crypto/rand"
"errors"
"fmt"
mrand "math/rand"
"testing"
"github.com/decred/dcrd/chaincfg/chainhash"
"github.com/decred/dcrd/chaincfg/v3"
"github.com/decred/dcrd/dcrec"
"github.com/decred/dcrd/dcrec/edwards/v2"
"github.com/decred/dcrd/dcrec/secp256k1/v3"
"github.com/decred/dcrd/dcrutil/v3"
"github.com/decred/dcrd/wire"
)
// testingParams defines the chain params to use throughout these tests so it
// can more easily be changed if desired.
var testingParams = chaincfg.RegNetParams()
const (
testValueIn = 12345
// noTreasury signifies the treasury agenda should be treated as though
// it is inactive. It is used to increase the readability of the
// tests.
noTreasury = false
// withTreasury signifies the treasury agenda should be treated as
// though it is active. It is used to increase the readability of
// the tests.
withTreasury = true
)
type addressToKey struct {
key []byte
sigType dcrec.SignatureType
compressed bool
}
func mkGetKey(keys map[string]addressToKey) KeyDB {
if keys == nil {
return KeyClosure(func(addr dcrutil.Address) ([]byte,
dcrec.SignatureType, bool, error) {
return nil, 0, false, errors.New("nope 1")
})
}
return KeyClosure(func(addr dcrutil.Address) ([]byte,
dcrec.SignatureType, bool, error) {
a2k, ok := keys[addr.Address()]
if !ok {
return nil, 0, false, errors.New("nope 2")
}
return a2k.key, a2k.sigType, a2k.compressed, nil
})
}
func mkGetKeyPub(keys map[string]addressToKey) KeyDB {
if keys == nil {
return KeyClosure(func(addr dcrutil.Address) ([]byte,
dcrec.SignatureType, bool, error) {
return nil, 0, false, errors.New("nope 1")
})
}
return KeyClosure(func(addr dcrutil.Address) ([]byte,
dcrec.SignatureType, bool, error) {
a2k, ok := keys[addr.String()]
if !ok {
return nil, 0, false, errors.New("nope 2")
}
return a2k.key, a2k.sigType, a2k.compressed, nil
})
}
func mkGetScript(scripts map[string][]byte) ScriptDB {
if scripts == nil {
return ScriptClosure(func(addr dcrutil.Address) (
[]byte, error) {
return nil, errors.New("nope 3")
})
}
return ScriptClosure(func(addr dcrutil.Address) ([]byte,
error) {
script, ok := scripts[addr.Address()]
if !ok {
return nil, errors.New("nope 4")
}
return script, nil
})
}
func checkScripts(msg string, tx *wire.MsgTx, idx int, sigScript, pkScript []byte) error {
tx.TxIn[idx].SignatureScript = sigScript
var scriptFlags ScriptFlags
vm, err := NewEngine(pkScript, tx, idx, scriptFlags, 0, nil)
if err != nil {
return fmt.Errorf("failed to make script engine for %s: %v",
msg, err)
}
err = vm.Execute()
if err != nil {
return fmt.Errorf("invalid script signature for %s: %v", msg,
err)
}
return nil
}
func signAndCheck(msg string, tx *wire.MsgTx, idx int, pkScript []byte, hashType SigHashType, kdb KeyDB, sdb ScriptDB, isTreasuryEnabled bool) error {
sigScript, err := SignTxOutput(testingParams, tx, idx, pkScript,
hashType, kdb, sdb, nil, isTreasuryEnabled)
if err != nil {
return fmt.Errorf("failed to sign output %s: %v", msg, err)
}
return checkScripts(msg, tx, idx, sigScript, pkScript)
}
func signBadAndCheck(msg string, tx *wire.MsgTx, idx int, pkScript []byte, hashType SigHashType, kdb KeyDB, sdb ScriptDB, isTreasuryEnabled bool) error {
// Setup a PRNG.
randScriptHash := chainhash.HashB(pkScript)
tRand := mrand.New(mrand.NewSource(int64(randScriptHash[0])))
sigScript, err := SignTxOutput(testingParams, tx,
idx, pkScript, hashType, kdb, sdb, nil, isTreasuryEnabled)
if err != nil {
return fmt.Errorf("failed to sign output %s: %v", msg, err)
}
// Be sure to reset the value in when we're done creating the
// corrupted signature for that flag.
tx.TxIn[0].ValueIn = testValueIn
// Corrupt a random bit in the signature.
pos := tRand.Intn(len(sigScript) - 1)
bitPos := tRand.Intn(7)
sigScript[pos] ^= 1 << uint8(bitPos)
return checkScripts(msg, tx, idx, sigScript, pkScript)
}
func TestSignTxOutput(t *testing.T) {
t.Parallel()
// make key
// make script based on key.
// sign with magic pixie dust.
hashTypes := []SigHashType{
SigHashAll,
SigHashNone,
SigHashSingle,
SigHashAll | SigHashAnyOneCanPay,
SigHashNone | SigHashAnyOneCanPay,
SigHashSingle | SigHashAnyOneCanPay,
}
signatureSuites := []dcrec.SignatureType{
dcrec.STEcdsaSecp256k1,
dcrec.STEd25519,
dcrec.STSchnorrSecp256k1,
}
tx := &wire.MsgTx{
SerType: wire.TxSerializeFull,
Version: 1,
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash{},
Index: 0,
Tree: 0,
},
Sequence: 4294967295,
ValueIn: testValueIn,
BlockHeight: 78901,
BlockIndex: 23456,
},
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash{},
Index: 1,
Tree: 0,
},
Sequence: 4294967295,
ValueIn: testValueIn,
BlockHeight: 78901,
BlockIndex: 23456,
},
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash{},
Index: 2,
Tree: 0,
},
Sequence: 4294967295,
ValueIn: testValueIn,
BlockHeight: 78901,
BlockIndex: 23456,
},
},
TxOut: []*wire.TxOut{
{
Version: wire.DefaultPkScriptVersion,
Value: 1,
},
{
Version: wire.DefaultPkScriptVersion,
Value: 2,
},
{
Version: wire.DefaultPkScriptVersion,
Value: 3,
},
},
LockTime: 0,
Expiry: 0,
}
// Pay to Pubkey Hash (uncompressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeUncompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to Pubkey Hash (uncompressed) (merging with correct)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeUncompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
sigScript, err := SignTxOutput(
testingParams, tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(
testingParams, tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
sigScript, err = SignTxOutput(
testingParams, tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(
testingParams, tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Pay to Pubkey Hash (compressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to Pubkey Hash (compressed) with duplicate merge
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
sigScript, err := SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript,
hashType, mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Pay to Pubkey Hash for a ticket(SStx) (compressed)
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB := privKey.Serialize()
pkBytes := privKey.PubKey().SerializeCompressed()
suite := dcrec.STEcdsaSecp256k1
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToSStx(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
// Pay to Pubkey Hash for a ticket change (SStx change) (compressed)
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB := privKey.Serialize()
pkBytes := privKey.PubKey().SerializeCompressed()
suite := dcrec.STEcdsaSecp256k1
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToSStxChange(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
// Pay to Pubkey Hash for a ticket spending (SSGen) (compressed)
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB := privKey.Serialize()
pkBytes := privKey.PubKey().SerializeCompressed()
suite := dcrec.STEcdsaSecp256k1
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToSSGen(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
// Pay to Pubkey Hash for a ticket revocation (SSRtx) (compressed)
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB := privKey.Serialize()
pkBytes := privKey.PubKey().SerializeCompressed()
suite := dcrec.STEcdsaSecp256k1
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams,
suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToSSRtx(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
// Pay to PubKey (uncompressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
privKey, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB := privKey.Serialize()
pk := privKey.PubKey()
suite := dcrec.STEcdsaSecp256k1
// For address generation, consensus rules require using
// a compressed public key. Look up ExtractPkScriptAddrs
// for more details
address, err := dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, dcrec.STEcdsaSecp256k1, false},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, dcrec.STEcdsaSecp256k1, false},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to PubKey (uncompressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
// For address generation, consensus rules require using
// a compressed public key. Look up ExtractPkScriptAddrs
// for more details
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
sigScript, err := SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, false},
}), mkGetScript(nil), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, false},
}), mkGetScript(nil), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
}
// With treasury agenda.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, false},
}), mkGetScript(nil), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, false},
}), mkGetScript(nil), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
}
}
}
}
// Pay to PubKey (compressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
// For address generation, consensus rules require using
// a compressed public key. Look up ExtractPkScriptAddrs
// for more details
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKeyPub(map[string]addressToKey{
address.String(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to PubKey (compressed) with duplicate merge
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
// Without treasury agenda.
sigScript, err := SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, pkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// As before, but with p2sh now.
// Pay to Pubkey Hash (uncompressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeUncompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams, suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
break
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to Pubkey Hash (uncompressed) with duplicate merge
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeUncompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams, suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
break
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
_, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err := SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// Wit treasury agenda.
_, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Pay to Pubkey Hash (compressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams, suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to Pubkey Hash (compressed) with duplicate merge
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
}
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
address, err := dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(pkBytes), testingParams, suite)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err := SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Pay to PubKey (uncompressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
// For address generation, consensus rules require using
// a compressed public key. Look up ExtractPkScriptAddrs
// for more details
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), noTreasury); err != nil {
t.Error(err)
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), withTreasury); err != nil {
t.Error(err)
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to PubKey (uncompressed) with duplicate merge
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
// For address generation, consensus rules require using
// a compressed public key. Look up ExtractPkScriptAddrs
// for more details
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeUncompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
}
// Without treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err := SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Pay to PubKey (compressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, false},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
}
// Pay to PubKey (compressed)
for _, hashType := range hashTypes {
for _, suite := range signatureSuites {
for i := range tx.TxIn {
var keyDB, pkBytes []byte
var address dcrutil.Address
var err error
msg := fmt.Sprintf("%d:%d:%d", hashType, i, suite)
switch suite {
case dcrec.STEcdsaSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pk := privKey.PubKey()
address, err = dcrutil.NewAddressSecpPubKeyCompressed(pk,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STEd25519:
keyDB, _, _, _ = edwards.GenerateKey(rand.Reader)
_, pk := edwards.PrivKeyFromBytes(keyDB)
pkBytes = pk.SerializeCompressed()
address, err = dcrutil.NewAddressEdwardsPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
case dcrec.STSchnorrSecp256k1:
privKey, _ := secp256k1.GeneratePrivateKey()
keyDB = privKey.Serialize()
pkBytes = privKey.PubKey().SerializeCompressed()
address, err = dcrutil.NewAddressSecSchnorrPubKey(pkBytes,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
}
}
pkScript, err := PayToAddrScript(address)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(
scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err := SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
_, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// by the above loop, this should be valid, now sign
// again and merge.
sigScript, err = SignTxOutput(testingParams,
tx, i, scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address.Address(): {keyDB, suite, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s a "+
"second time: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript, scriptPkScript)
if err != nil {
t.Errorf("twice signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
// Basic Multisig
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey1, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB1 := privKey1.Serialize()
pk1 := privKey1.PubKey()
suite1 := dcrec.STEcdsaSecp256k1
address1, err := dcrutil.NewAddressSecpPubKeyCompressed(pk1,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
privKey2, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB2 := privKey2.Serialize()
pk2 := privKey2.PubKey()
suite2 := dcrec.STEcdsaSecp256k1
address2, err := dcrutil.NewAddressSecpPubKeyCompressed(pk2,
testingParams)
if err != nil {
t.Errorf("failed to make address 2 for %s: %v",
msg, err)
break
}
pkScript, err := MultiSigScript(
[]*dcrutil.AddressSecpPubKey{address1, address2},
2)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), noTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(nil), noTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
// With treasury agenda.
if err := signAndCheck(msg, tx, i, scriptPkScript,
hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), withTreasury); err != nil {
t.Error(err)
break
}
if err := signBadAndCheck(msg, tx, i, pkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(nil), withTreasury); err == nil {
t.Errorf("corrupted signature validated: %s", msg)
break
}
}
}
// Two part multisig, sign with one key then the other.
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey1, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB1 := privKey1.Serialize()
pk1 := privKey1.PubKey()
suite1 := dcrec.STEcdsaSecp256k1
address1, err := dcrutil.NewAddressSecpPubKeyCompressed(pk1,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
privKey2, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB2 := privKey2.Serialize()
pk2 := privKey2.PubKey()
suite2 := dcrec.STEcdsaSecp256k1
address2, err := dcrutil.NewAddressSecpPubKeyCompressed(pk2,
testingParams)
if err != nil {
t.Errorf("failed to make address 2 for %s: %v",
msg, err)
break
}
pkScript, err := MultiSigScript(
[]*dcrutil.AddressSecpPubKey{address1, address2},
2)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
sigScript, err := SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// Only 1 out of 2 signed, this *should* fail.
if checkScripts(msg, tx, i, sigScript,
scriptPkScript) == nil {
t.Errorf("part signed script valid for %s", msg)
break
}
// Sign with the other key and merge
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript,
scriptPkScript)
if err != nil {
t.Errorf("fully signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// Only 1 out of 2 signed, this *should* fail.
if checkScripts(msg, tx, i, sigScript,
scriptPkScript) == nil {
t.Errorf("part signed script valid for %s", msg)
break
}
// Sign with the other key and merge
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg, err)
break
}
err = checkScripts(msg, tx, i, sigScript,
scriptPkScript)
if err != nil {
t.Errorf("fully signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
// Two part multisig, sign with one key then both, check key dedup
// correctly.
for _, hashType := range hashTypes {
for i := range tx.TxIn {
msg := fmt.Sprintf("%d:%d", hashType, i)
privKey1, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB1 := privKey1.Serialize()
pk1 := privKey1.PubKey()
suite1 := dcrec.STEcdsaSecp256k1
address1, err := dcrutil.NewAddressSecpPubKeyCompressed(pk1,
testingParams)
if err != nil {
t.Errorf("failed to make address for %s: %v",
msg, err)
break
}
privKey2, err := secp256k1.GeneratePrivateKey()
if err != nil {
t.Errorf("failed to generate key: %v", err)
break
}
keyDB2 := privKey2.Serialize()
pk2 := privKey2.PubKey()
suite2 := dcrec.STEcdsaSecp256k1
address2, err := dcrutil.NewAddressSecpPubKeyCompressed(pk2,
testingParams)
if err != nil {
t.Errorf("failed to make address 2 for %s: %v",
msg, err)
break
}
pkScript, err := MultiSigScript(
[]*dcrutil.AddressSecpPubKey{address1, address2},
2)
if err != nil {
t.Errorf("failed to make pkscript "+
"for %s: %v", msg, err)
}
scriptAddr, err := dcrutil.NewAddressScriptHash(
pkScript, testingParams)
if err != nil {
t.Errorf("failed to make p2sh addr for %s: %v",
msg, err)
break
}
scriptPkScript, err := PayToAddrScript(scriptAddr)
if err != nil {
t.Errorf("failed to make script pkscript for "+
"%s: %v", msg, err)
break
}
// Without treasury agenda.
sigScript, err := SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// Only 1 out of 2 signed, this *should* fail.
if checkScripts(msg, tx, i, sigScript,
scriptPkScript) == nil {
t.Errorf("part signed script valid for %s", msg)
break
}
// Sign with the other key and merge
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), sigScript, noTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg, err)
break
}
// Now we should pass.
err = checkScripts(msg, tx, i, sigScript,
scriptPkScript)
if err != nil {
t.Errorf("fully signed script invalid for "+
"%s: %v", msg, err)
break
}
// With treasury agenda.
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), nil, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg,
err)
break
}
// Only 1 out of 2 signed, this *should* fail.
if checkScripts(msg, tx, i, sigScript,
scriptPkScript) == nil {
t.Errorf("part signed script valid for %s", msg)
break
}
// Sign with the other key and merge
sigScript, err = SignTxOutput(testingParams, tx, i,
scriptPkScript, hashType,
mkGetKey(map[string]addressToKey{
address1.Address(): {keyDB1, suite1, true},
address2.Address(): {keyDB2, suite2, true},
}), mkGetScript(map[string][]byte{
scriptAddr.Address(): pkScript,
}), sigScript, withTreasury)
if err != nil {
t.Errorf("failed to sign output %s: %v", msg, err)
break
}
// Now we should pass.
err = checkScripts(msg, tx, i, sigScript,
scriptPkScript)
if err != nil {
t.Errorf("fully signed script invalid for "+
"%s: %v", msg, err)
break
}
}
}
}
type tstInput struct {
txout *wire.TxOut
sigscriptGenerates bool
inputValidates bool
indexOutOfRange bool
}
type tstSigScript struct {
name string
inputs []tstInput
hashType SigHashType
compress bool
scriptAtWrongIndex bool
}
var coinbaseOutPoint = &wire.OutPoint{
Index: (1 << 32) - 1,
}
// Pregenerated private key, with associated public key and pkScripts
// for the uncompressed and compressed hash160.
var (
privKeyD = []byte{0x6b, 0x0f, 0xd8, 0xda, 0x54, 0x22, 0xd0, 0xb7,
0xb4, 0xfc, 0x4e, 0x55, 0xd4, 0x88, 0x42, 0xb3, 0xa1, 0x65,
0xac, 0x70, 0x7f, 0x3d, 0xa4, 0x39, 0x5e, 0xcb, 0x3b, 0xb0,
0xd6, 0x0e, 0x06, 0x92}
thisPubKey = secp256k1.PrivKeyFromBytes(privKeyD).PubKey()
thisAddressUnc, _ = dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(thisPubKey.SerializeUncompressed()),
testingParams, dcrec.STEcdsaSecp256k1)
uncompressedPkScript, _ = PayToAddrScript(thisAddressUnc)
thisAddressCom, _ = dcrutil.NewAddressPubKeyHash(
dcrutil.Hash160(thisPubKey.SerializeCompressed()),
testingParams, dcrec.STEcdsaSecp256k1)
compressedPkScript, _ = PayToAddrScript(thisAddressCom)
shortPkScript = []byte{0x76, 0xa9, 0x14, 0xd1, 0x7c, 0xb5,
0xeb, 0xa4, 0x02, 0xcb, 0x68, 0xe0, 0x69, 0x56, 0xbf, 0x32,
0x53, 0x90, 0x0e, 0x0a, 0x88, 0xac}
)
// Pretend output amounts.
const coinbaseVal = 2500000000
const fee = 5000000
var sigScriptTests = []tstSigScript{
{
name: "one input uncompressed",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "two inputs uncompressed",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
{
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "one input compressed",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, compressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: true,
scriptAtWrongIndex: false,
},
{
name: "two inputs compressed",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, compressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
{
txout: wire.NewTxOut(coinbaseVal+fee, compressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: true,
scriptAtWrongIndex: false,
},
{
name: "hashType SigHashNone",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashNone,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "hashType SigHashSingle",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashSingle,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "hashType SigHashAnyoneCanPay",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAnyOneCanPay | SigHashAll,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "hashType non-standard",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: false,
indexOutOfRange: false,
},
},
hashType: 0x04,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "invalid compression",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: false,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: true,
scriptAtWrongIndex: false,
},
{
name: "short PkScript",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, shortPkScript),
sigscriptGenerates: false,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: false,
scriptAtWrongIndex: false,
},
{
name: "valid script at wrong index",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
{
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: false,
scriptAtWrongIndex: true,
},
{
name: "index out of range",
inputs: []tstInput{
{
txout: wire.NewTxOut(coinbaseVal, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
{
txout: wire.NewTxOut(coinbaseVal+fee, uncompressedPkScript),
sigscriptGenerates: true,
inputValidates: true,
indexOutOfRange: false,
},
},
hashType: SigHashAll,
compress: false,
scriptAtWrongIndex: true,
},
}
// Test the sigscript generation for valid and invalid inputs, all
// hashTypes, and with and without compression. This test creates
// sigscripts to spend fake coinbase inputs, as sigscripts cannot be
// created for the MsgTxs in txTests, since they come from the blockchain
// and we don't have the private keys.
func TestSignatureScript(t *testing.T) {
t.Parallel()
nexttest:
for i := range sigScriptTests {
tx := wire.NewMsgTx()
output := wire.NewTxOut(500, []byte{OP_RETURN})
tx.AddTxOut(output)
for range sigScriptTests[i].inputs {
txin := wire.NewTxIn(coinbaseOutPoint, 500, nil)
tx.AddTxIn(txin)
}
var script []byte
var err error
for j := range tx.TxIn {
var idx int
if sigScriptTests[i].inputs[j].indexOutOfRange {
t.Errorf("at test %v", sigScriptTests[i].name)
idx = len(sigScriptTests[i].inputs)
} else {
idx = j
}
script, err = SignatureScript(tx, idx,
sigScriptTests[i].inputs[j].txout.PkScript,
sigScriptTests[i].hashType, privKeyD, dcrec.STEcdsaSecp256k1,
sigScriptTests[i].compress)
if (err == nil) != sigScriptTests[i].inputs[j].sigscriptGenerates {
if err == nil {
t.Errorf("passed test '%v' incorrectly",
sigScriptTests[i].name)
} else {
t.Errorf("failed test '%v': %v",
sigScriptTests[i].name, err)
}
continue nexttest
}
if !sigScriptTests[i].inputs[j].sigscriptGenerates {
// done with this test
continue nexttest
}
tx.TxIn[j].SignatureScript = script
}
// If testing using a correct sigscript but for an incorrect
// index, use last input script for first input. Requires > 0
// inputs for test.
if sigScriptTests[i].scriptAtWrongIndex {
tx.TxIn[0].SignatureScript = script
sigScriptTests[i].inputs[0].inputValidates = false
}
// Validate tx input scripts
var scriptFlags ScriptFlags
for j := range tx.TxIn {
vm, err := NewEngine(sigScriptTests[i].inputs[j].txout.
PkScript, tx, j, scriptFlags, 0,
nil)
if err != nil {
t.Errorf("cannot create script vm for test %v: %v",
sigScriptTests[i].name, err)
continue nexttest
}
err = vm.Execute()
if (err == nil) != sigScriptTests[i].inputs[j].inputValidates {
if err == nil {
t.Errorf("passed test '%v' validation incorrectly: %v",
sigScriptTests[i].name, err)
} else {
t.Errorf("failed test '%v' validation: %v",
sigScriptTests[i].name, err)
}
continue nexttest
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink