func TestIncorrectTransactionPOWVerification(t *testing.T) {
pow := helpers.ArrayOfBytes(TEST_TRANSACTION_POW_COMPLEXITY, TEST_POW_PREFIX)
powIncorrect := helpers.ArrayOfBytes(TEST_TRANSACTION_POW_COMPLEXITY, 'a')
kp := GenerateNewKeypair()
tr := NewTransaction(kp.Public, nil, []byte(helpers.RandomString(helpers.RandomInt(0, 1024))))
tr.Header.Nonce = tr.GenerateNonce(powIncorrect)
tr.Signature = tr.Sign(kp)
if tr.VerifyTransaction(pow) {
t.Error("Passed validation without pow")
}
}
func TestTransactionMarshalling(t *testing.T) {
kp := GenerateNewKeypair()
tr := NewTransaction(kp.Public, nil, []byte(helpers.RandomString(helpers.RandomInt(0, 1024*1024))))
tr.Header.Nonce = tr.GenerateNonce(helpers.ArrayOfBytes(TEST_TRANSACTION_POW_COMPLEXITY, TEST_POW_PREFIX))
tr.Signature = tr.Sign(kp)
data, err := tr.MarshalBinary()
if err != nil {
t.Error(err)
}
newT := &Transaction{}
rem, err := newT.UnmarshalBinary(data)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(*newT, *tr) || len(rem) < 0 {
t.Error("Marshall, unmarshall failed")
}
}
func TestTransactionVerification(t *testing.T) {
pow := helpers.ArrayOfBytes(TEST_TRANSACTION_POW_COMPLEXITY, TEST_POW_PREFIX)
kp := GenerateNewKeypair()
tr := NewTransaction(kp.Public, nil, []byte(helpers.RandomString(helpers.RandomInt(0, 1024))))
tr.Header.Nonce = tr.GenerateNonce(pow)
tr.Signature = tr.Sign(kp)
if !tr.VerifyTransaction(pow) {
t.Error("Validation failing")
}
}
func bigJoin(expectedLen int, bigs ...*big.Int) *big.Int {
bs := []byte{}
for i, b := range bigs {
by := b.Bytes()
dif := expectedLen - len(by)
if dif > 0 && i != 0 {
by = append(helpers.ArrayOfBytes(dif, 0), by...)
}
bs = append(bs, by...)
}
b := new(big.Int).SetBytes(bs)
return b
}
func TestKeySigning(t *testing.T) {
for i := 0; i < 5; i++ {
keypair := GenerateNewKeypair()
data := helpers.ArrayOfBytes(i, 'a')
hash := helpers.SHA256(data)
signature, err := keypair.Sign(hash)
if err != nil {
t.Error("base58 error")
} else if !SignatureVerify(keypair.Public, signature, hash) {
t.Error("Signing and verifying error", len(keypair.Public))
}
}
}
package core
import (
"reflect"
"github.com/izqui/helpers"
)
var (
TRANSACTION_POW = helpers.ArrayOfBytes(TRANSACTION_POW_COMPLEXITY, POW_PREFIX)
BLOCK_POW = helpers.ArrayOfBytes(BLOCK_POW_COMPLEXITY, POW_PREFIX)
TEST_TRANSACTION_POW = helpers.ArrayOfBytes(TEST_TRANSACTION_POW_COMPLEXITY, POW_PREFIX)
TEST_BLOCK_POW = helpers.ArrayOfBytes(TEST_BLOCK_POW_COMPLEXITY, POW_PREFIX)
)
func CheckProofOfWork(prefix []byte, hash []byte) bool {
if len(prefix) > 0 {
return reflect.DeepEqual(prefix, hash[:len(prefix)])
}
return true
}