mirror of https://github.com/poanetwork/gecko.git
1697 lines
35 KiB
Go
1697 lines
35 KiB
Go
// (c) 2019-2020, Ava Labs, Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package avm
|
|
|
|
import (
|
|
"bytes"
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/ava-labs/gecko/database/memdb"
|
|
"github.com/ava-labs/gecko/ids"
|
|
"github.com/ava-labs/gecko/snow/engine/common"
|
|
"github.com/ava-labs/gecko/utils/crypto"
|
|
"github.com/ava-labs/gecko/vms/components/ava"
|
|
"github.com/ava-labs/gecko/vms/secp256k1fx"
|
|
)
|
|
|
|
func TestBaseTxSerialization(t *testing.T) {
|
|
expected := []byte{
|
|
// txID:
|
|
0x00, 0x00, 0x00, 0x00,
|
|
// networkID:
|
|
0x00, 0x00, 0xa8, 0x66,
|
|
// blockchainID:
|
|
0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
// number of outs:
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// output[0]:
|
|
// assetID:
|
|
0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
// fxID:
|
|
0x00, 0x00, 0x00, 0x07,
|
|
// secp256k1 Transferable Output:
|
|
// amount:
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x39,
|
|
// locktime:
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
// threshold:
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// number of addresses
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// address[0]
|
|
0xfc, 0xed, 0xa8, 0xf9, 0x0f, 0xcb, 0x5d, 0x30,
|
|
0x61, 0x4b, 0x99, 0xd7, 0x9f, 0xc4, 0xba, 0xa2,
|
|
0x93, 0x07, 0x76, 0x26,
|
|
// number of inputs:
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// txID:
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
// utxo index:
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// assetID:
|
|
0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
// fxID:
|
|
0x00, 0x00, 0x00, 0x05,
|
|
// amount:
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd4, 0x31,
|
|
// number of signatures:
|
|
0x00, 0x00, 0x00, 0x01,
|
|
// signature index[0]:
|
|
0x00, 0x00, 0x00, 0x02,
|
|
}
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
c := setupCodec()
|
|
|
|
b, err := c.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
result := tx.Bytes()
|
|
if !bytes.Equal(expected, result) {
|
|
t.Fatalf("\nExpected: 0x%x\nResult: 0x%x", expected, result)
|
|
}
|
|
}
|
|
|
|
func TestBaseTxGetters(t *testing.T) {
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
txID := tx.ID()
|
|
|
|
if assets := tx.AssetIDs(); assets.Len() != 1 {
|
|
t.Fatalf("Wrong number of assets returned")
|
|
} else if !assets.Contains(asset) {
|
|
t.Fatalf("Wrong asset returned")
|
|
} else if assets := tx.ConsumedAssetIDs(); assets.Len() != 1 {
|
|
t.Fatalf("Wrong number of consumed assets returned")
|
|
} else if !assets.Contains(asset) {
|
|
t.Fatalf("Wrong consumed asset returned")
|
|
} else if utxos := tx.UTXOs(); len(utxos) != 1 {
|
|
t.Fatalf("Wrong number of utxos returned")
|
|
} else if utxo := utxos[0]; !utxo.TxID.Equals(txID) {
|
|
t.Fatalf("Wrong tx ID returned")
|
|
} else if utxoIndex := utxo.OutputIndex; utxoIndex != 0 {
|
|
t.Fatalf("Wrong output index returned")
|
|
} else if assetID := utxo.AssetID(); !assetID.Equals(asset) {
|
|
t.Fatalf("Wrong asset ID returned")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerify(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyNil(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := (*BaseTx)(nil)
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Nil BaseTx should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyWrongNetworkID(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: 0,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Wrong networkID should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyWrongChainID(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: ids.Empty,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Wrong chain ID should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyInvalidOutput(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{nil},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Invalid output should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyUnsortedOutputs(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{
|
|
{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 2,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 1,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Ins: []*ava.TransferableInput{
|
|
{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Unsorted outputs should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyInvalidInput(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{nil},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Invalid input should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyInputOverflow(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{
|
|
{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: math.MaxUint64,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 1,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Input overflow should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyOutputOverflow(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{
|
|
{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 2,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: math.MaxUint64,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 1,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Output overflow should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyInsufficientFunds(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: math.MaxUint64,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 1,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
tx.Initialize([]byte{})
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Insufficient funds should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSyntacticVerifyUninitialized(t *testing.T) {
|
|
c := setupCodec()
|
|
|
|
tx := &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: asset},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 12345,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.NewID([32]byte{
|
|
0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
|
|
0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0,
|
|
0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8,
|
|
0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0,
|
|
}),
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 54321,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{2},
|
|
},
|
|
},
|
|
}},
|
|
}
|
|
|
|
if err := tx.SyntacticVerify(ctx, c, 0); err == nil {
|
|
t.Fatalf("Uninitialized tx should have errored")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerify(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyUnknownFx(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.codec.RegisterType(&ava.TestVerifiable{})
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
tx.Creds = append(tx.Creds, &ava.TestVerifiable{})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("should have errored due to an unknown feature extension")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyWrongAssetID(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.codec.RegisterType(&ava.TestVerifiable{})
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("should have errored due to an asset ID mismatch")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyUnauthorizedFx(t *testing.T) {
|
|
vm := &VM{}
|
|
ctx.Lock.Lock()
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
genesisBytes := BuildGenesisTest(t)
|
|
issuer := make(chan common.Message, 1)
|
|
err := vm.Initialize(
|
|
ctx,
|
|
memdb.New(),
|
|
genesisBytes,
|
|
issuer,
|
|
[]*common.Fx{
|
|
{
|
|
ID: ids.Empty,
|
|
Fx: &secp256k1fx.Fx{},
|
|
},
|
|
{
|
|
ID: ids.NewID([32]byte{1}),
|
|
Fx: &testFx{},
|
|
},
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
vm.batchTimeout = 0
|
|
|
|
err = vm.Bootstrapping()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = vm.Bootstrapped()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cr := codecRegistry{
|
|
index: 1,
|
|
typeToFxIndex: vm.typeToFxIndex,
|
|
codec: vm.codec,
|
|
}
|
|
|
|
cr.RegisterType(&ava.TestTransferable{})
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &ava.TestTransferable{},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("should have errored due to an unsupported fx")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyInvalidSignature(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{{}},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Invalid credential should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyMissingUTXO(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: ids.Empty,
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Unknown UTXO should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyInvalidUTXO(t *testing.T) {
|
|
genesisBytes, _, vm := GenesisVM(t)
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: math.MaxUint32,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Invalid UTXO should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyPendingInvalidUTXO(t *testing.T) {
|
|
genesisBytes, issuer, vm := GenesisVM(t)
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
pendingTx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 50000,
|
|
Locktime: 0,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&pendingTx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
pendingTx.Creds = append(pendingTx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(pendingTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
txID, err := vm.IssueTx(b, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx.Lock.Unlock()
|
|
|
|
<-issuer
|
|
|
|
ctx.Lock.Lock()
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.PendingTxs()
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: txID,
|
|
OutputIndex: 2,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err = vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sig, err = key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig = [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err = vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Invalid UTXO should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyPendingWrongAssetID(t *testing.T) {
|
|
genesisBytes, issuer, vm := GenesisVM(t)
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
pendingTx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 50000,
|
|
Locktime: 0,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&pendingTx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
pendingTx.Creds = append(pendingTx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(pendingTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
txID, err := vm.IssueTx(b, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx.Lock.Unlock()
|
|
|
|
<-issuer
|
|
|
|
ctx.Lock.Lock()
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.PendingTxs()
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: txID,
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: asset},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err = vm.codec.Marshal(&tx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sig, err = key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig = [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err = vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Wrong asset ID should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyPendingUnauthorizedFx(t *testing.T) {
|
|
genesisBytes := BuildGenesisTest(t)
|
|
|
|
issuer := make(chan common.Message, 1)
|
|
|
|
ctx.Lock.Lock()
|
|
|
|
vm := &VM{}
|
|
err := vm.Initialize(
|
|
ctx,
|
|
memdb.New(),
|
|
genesisBytes,
|
|
issuer,
|
|
[]*common.Fx{
|
|
{
|
|
ID: ids.NewID([32]byte{1}),
|
|
Fx: &secp256k1fx.Fx{},
|
|
},
|
|
{
|
|
ID: ids.Empty,
|
|
Fx: &testFx{},
|
|
},
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
vm.batchTimeout = 0
|
|
|
|
err = vm.Bootstrapping()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = vm.Bootstrapped()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cr := codecRegistry{
|
|
index: 1,
|
|
typeToFxIndex: vm.typeToFxIndex,
|
|
codec: vm.codec,
|
|
}
|
|
|
|
cr.RegisterType(&ava.TestVerifiable{})
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
pendingTx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 50000,
|
|
Locktime: 0,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&pendingTx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
pendingTx.Creds = append(pendingTx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(pendingTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
txID, err := vm.IssueTx(b, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx.Lock.Unlock()
|
|
|
|
<-issuer
|
|
|
|
ctx.Lock.Lock()
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.PendingTxs()
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: txID,
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
tx.Creds = append(tx.Creds, &ava.TestVerifiable{})
|
|
|
|
b, err = vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Unsupported feature extension should have failed verification")
|
|
}
|
|
}
|
|
|
|
func TestBaseTxSemanticVerifyPendingInvalidSignature(t *testing.T) {
|
|
genesisBytes := BuildGenesisTest(t)
|
|
|
|
issuer := make(chan common.Message, 1)
|
|
|
|
ctx.Lock.Lock()
|
|
|
|
vm := &VM{}
|
|
err := vm.Initialize(
|
|
ctx,
|
|
memdb.New(),
|
|
genesisBytes,
|
|
issuer,
|
|
[]*common.Fx{
|
|
{
|
|
ID: ids.NewID([32]byte{1}),
|
|
Fx: &secp256k1fx.Fx{},
|
|
},
|
|
{
|
|
ID: ids.Empty,
|
|
Fx: &testFx{},
|
|
},
|
|
},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
vm.batchTimeout = 0
|
|
|
|
err = vm.Bootstrapping()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
err = vm.Bootstrapped()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cr := codecRegistry{
|
|
index: 1,
|
|
typeToFxIndex: vm.typeToFxIndex,
|
|
codec: vm.codec,
|
|
}
|
|
|
|
cr.RegisterType(&ava.TestVerifiable{})
|
|
|
|
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
|
|
|
|
pendingTx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: genesisTx.ID(),
|
|
OutputIndex: 1,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
Outs: []*ava.TransferableOutput{{
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
Out: &secp256k1fx.TransferOutput{
|
|
Amt: 50000,
|
|
Locktime: 0,
|
|
OutputOwners: secp256k1fx.OutputOwners{
|
|
Threshold: 1,
|
|
Addrs: []ids.ShortID{keys[0].PublicKey().Address()},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
unsignedBytes, err := vm.codec.Marshal(&pendingTx.UnsignedTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
key := keys[0]
|
|
sig, err := key.Sign(unsignedBytes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixedSig := [crypto.SECP256K1RSigLen]byte{}
|
|
copy(fixedSig[:], sig)
|
|
|
|
pendingTx.Creds = append(pendingTx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{
|
|
fixedSig,
|
|
},
|
|
})
|
|
|
|
b, err := vm.codec.Marshal(pendingTx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
txID, err := vm.IssueTx(b, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ctx.Lock.Unlock()
|
|
|
|
<-issuer
|
|
|
|
ctx.Lock.Lock()
|
|
defer func() {
|
|
vm.Shutdown()
|
|
ctx.Lock.Unlock()
|
|
}()
|
|
|
|
vm.PendingTxs()
|
|
|
|
tx := &Tx{UnsignedTx: &BaseTx{
|
|
NetID: networkID,
|
|
BCID: chainID,
|
|
Ins: []*ava.TransferableInput{{
|
|
UTXOID: ava.UTXOID{
|
|
TxID: txID,
|
|
OutputIndex: 0,
|
|
},
|
|
Asset: ava.Asset{ID: genesisTx.ID()},
|
|
In: &secp256k1fx.TransferInput{
|
|
Amt: 50000,
|
|
Input: secp256k1fx.Input{
|
|
SigIndices: []uint32{
|
|
0,
|
|
},
|
|
},
|
|
},
|
|
}},
|
|
}}
|
|
|
|
tx.Creds = append(tx.Creds, &secp256k1fx.Credential{
|
|
Sigs: [][crypto.SECP256K1RSigLen]byte{{}},
|
|
})
|
|
|
|
b, err = vm.codec.Marshal(tx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tx.Initialize(b)
|
|
|
|
uTx := &UniqueTx{
|
|
TxState: &TxState{
|
|
Tx: tx,
|
|
},
|
|
vm: vm,
|
|
txID: tx.ID(),
|
|
}
|
|
|
|
if err := tx.UnsignedTx.SemanticVerify(vm, uTx, tx.Creds); err == nil {
|
|
t.Fatalf("Invalid signature should have failed verification")
|
|
}
|
|
}
|