diff --git a/vms/avm/base_tx_test.go b/vms/avm/base_tx_test.go
index 1d3233f..e236230 100644
--- a/vms/avm/base_tx_test.go
+++ b/vms/avm/base_tx_test.go
@@ -622,29 +622,9 @@ func TestBaseTxSyntacticVerifyUninitialized(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerify(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	tx := &Tx{UnsignedTx: &BaseTx{
@@ -706,29 +686,9 @@ func TestBaseTxSemanticVerify(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyUnknownFx(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	vm.codec.RegisterType(&ava.TestVerifiable{})
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
@@ -775,29 +735,9 @@ func TestBaseTxSemanticVerifyUnknownFx(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyWrongAssetID(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	vm.codec.RegisterType(&ava.TestVerifiable{})
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
@@ -952,29 +892,9 @@ func TestBaseTxSemanticVerifyUnauthorizedFx(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyInvalidSignature(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	tx := &Tx{UnsignedTx: &BaseTx{
@@ -1023,29 +943,9 @@ func TestBaseTxSemanticVerifyInvalidSignature(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyMissingUTXO(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	tx := &Tx{UnsignedTx: &BaseTx{
@@ -1107,29 +1007,9 @@ func TestBaseTxSemanticVerifyMissingUTXO(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyInvalidUTXO(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
+	genesisBytes, _, vm := GenesisVM(t)
 	defer ctx.Lock.Unlock()
 
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	tx := &Tx{UnsignedTx: &BaseTx{
@@ -1191,27 +1071,7 @@ func TestBaseTxSemanticVerifyInvalidUTXO(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyPendingInvalidUTXO(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{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
+	genesisBytes, issuer, vm := GenesisVM(t)
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
@@ -1342,27 +1202,7 @@ func TestBaseTxSemanticVerifyPendingInvalidUTXO(t *testing.T) {
 }
 
 func TestBaseTxSemanticVerifyPendingWrongAssetID(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{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
+	genesisBytes, issuer, vm := GenesisVM(t)
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
diff --git a/vms/avm/prefixed_state_test.go b/vms/avm/prefixed_state_test.go
index 8a69f91..1d790d5 100644
--- a/vms/avm/prefixed_state_test.go
+++ b/vms/avm/prefixed_state_test.go
@@ -16,7 +16,8 @@ import (
 )
 
 func TestPrefixedSetsAndGets(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state
 
 	vm.codec.RegisterType(&ava.TestVerifiable{})
@@ -110,7 +111,8 @@ func TestPrefixedSetsAndGets(t *testing.T) {
 }
 
 func TestPrefixedFundingNoAddresses(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state
 
 	vm.codec.RegisterType(&ava.TestVerifiable{})
@@ -133,7 +135,8 @@ func TestPrefixedFundingNoAddresses(t *testing.T) {
 }
 
 func TestPrefixedFundingAddresses(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state
 
 	vm.codec.RegisterType(&testAddressable{})
diff --git a/vms/avm/service_test.go b/vms/avm/service_test.go
index 9221634..dff4c3e 100644
--- a/vms/avm/service_test.go
+++ b/vms/avm/service_test.go
@@ -4,20 +4,27 @@
 package avm
 
 import (
+	"fmt"
 	"testing"
 
+	"github.com/ava-labs/gecko/snow/choices"
+
 	"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/formatting"
 	"github.com/ava-labs/gecko/vms/secp256k1fx"
 )
 
-func TestGetAssetDescription(t *testing.T) {
+func setup(t *testing.T) ([]byte, *VM, *Service) {
 	genesisBytes := BuildGenesisTest(t)
 
 	ctx.Lock.Lock()
-	defer ctx.Lock.Unlock()
 
+	// This VM initilialzation is very similar to that done by GenesisVM().
+	// However replacing the body of this function, with a call to GenesisVM
+	// causes a timeout while executing the test suite.
+	// https://github.com/ava-labs/gecko/pull/59#pullrequestreview-392478636
 	vm := &VM{}
 	err := vm.Initialize(
 		ctx,
@@ -32,16 +39,163 @@ func TestGetAssetDescription(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	s := &Service{vm: vm}
+	return genesisBytes, vm, s
+}
+
+func TestServiceIssueTx(t *testing.T) {
+	genesisBytes, vm, s := setup(t)
+	defer ctx.Lock.Unlock()
+	defer vm.Shutdown()
+
+	txArgs := &IssueTxArgs{}
+	txReply := &IssueTxReply{}
+	err := s.IssueTx(nil, txArgs, txReply)
+	if err == nil {
+		t.Fatal("Expected empty transaction to return an error")
+	}
+
+	tx := NewTx(t, genesisBytes, vm)
+	txArgs.Tx = formatting.CB58{Bytes: tx.Bytes()}
+	txReply = &IssueTxReply{}
+	if err := s.IssueTx(nil, txArgs, txReply); err != nil {
+		t.Fatal(err)
+	}
+	if !txReply.TxID.Equals(tx.ID()) {
+		t.Fatalf("Expected %q, got %q", txReply.TxID, tx.ID())
+	}
+}
+
+func TestServiceGetTxStatus(t *testing.T) {
+	genesisBytes, vm, s := setup(t)
+	defer ctx.Lock.Unlock()
+	defer vm.Shutdown()
+
+	statusArgs := &GetTxStatusArgs{}
+	statusReply := &GetTxStatusReply{}
+	if err := s.GetTxStatus(nil, statusArgs, statusReply); err == nil {
+		t.Fatal("Expected empty transaction to return an error")
+	}
+
+	tx := NewTx(t, genesisBytes, vm)
+	statusArgs.TxID = tx.ID()
+	statusReply = &GetTxStatusReply{}
+	if err := s.GetTxStatus(nil, statusArgs, statusReply); err != nil {
+		t.Fatal(err)
+	}
+	if expected := choices.Unknown; expected != statusReply.Status {
+		t.Fatalf(
+			"Expected an unsubmitted tx to have status %q, got %q",
+			expected.String(), statusReply.Status.String(),
+		)
+	}
+
+	txArgs := &IssueTxArgs{Tx: formatting.CB58{Bytes: tx.Bytes()}}
+	txReply := &IssueTxReply{}
+	if err := s.IssueTx(nil, txArgs, txReply); err != nil {
+		t.Fatal(err)
+	}
+	statusReply = &GetTxStatusReply{}
+	if err := s.GetTxStatus(nil, statusArgs, statusReply); err != nil {
+		t.Fatal(err)
+	}
+	if expected := choices.Processing; expected != statusReply.Status {
+		t.Fatalf(
+			"Expected a submitted tx to have status %q, got %q",
+			expected.String(), statusReply.Status.String(),
+		)
+	}
+}
+
+func TestServiceGetUTXOsInvalidAddress(t *testing.T) {
+	_, vm, s := setup(t)
+	defer ctx.Lock.Unlock()
+	defer vm.Shutdown()
+
+	addr0 := keys[0].PublicKey().Address()
+	tests := []struct {
+		label string
+		args  *GetUTXOsArgs
+	}{
+		{"[", &GetUTXOsArgs{[]string{""}}},
+		{"[-]", &GetUTXOsArgs{[]string{"-"}}},
+		{"[foo]", &GetUTXOsArgs{[]string{"foo"}}},
+		{"[foo-bar]", &GetUTXOsArgs{[]string{"foo-bar"}}},
+		{"[<ChainID>]", &GetUTXOsArgs{[]string{ctx.ChainID.String()}}},
+		{"[<ChainID>-]", &GetUTXOsArgs{[]string{fmt.Sprintf("%s-", ctx.ChainID.String())}}},
+		{"[<Unknown ID>-<addr0>]", &GetUTXOsArgs{[]string{fmt.Sprintf("%s-%s", ids.NewID([32]byte{42}).String(), addr0.String())}}},
+	}
+	for _, tt := range tests {
+		t.Run(tt.label, func(t *testing.T) {
+			utxosReply := &GetUTXOsReply{}
+			if err := s.GetUTXOs(nil, tt.args, utxosReply); err == nil {
+				t.Error(err)
+			}
+		})
+	}
+}
+
+func TestServiceGetUTXOs(t *testing.T) {
+	_, vm, s := setup(t)
+	defer ctx.Lock.Unlock()
+	defer vm.Shutdown()
+
+	addr0 := keys[0].PublicKey().Address()
+	tests := []struct {
+		label string
+		args  *GetUTXOsArgs
+		count int
+	}{
+		{
+			"Empty",
+			&GetUTXOsArgs{},
+			0,
+		}, {
+			"[<ChainID>-<unrelated address>]",
+			&GetUTXOsArgs{[]string{
+				// TODO: Should GetUTXOs() raise an error for this? The address portion is
+				//		 longer than addr0.String()
+				fmt.Sprintf("%s-%s", ctx.ChainID.String(), ids.NewID([32]byte{42}).String()),
+			}},
+			0,
+		}, {
+			"[<ChainID>-<addr0>]",
+			&GetUTXOsArgs{[]string{
+				fmt.Sprintf("%s-%s", ctx.ChainID.String(), addr0.String()),
+			}},
+			7,
+		}, {
+			"[<ChainID>-<addr0>,<ChainID>-<addr0>]",
+			&GetUTXOsArgs{[]string{
+				fmt.Sprintf("%s-%s", ctx.ChainID.String(), addr0.String()),
+				fmt.Sprintf("%s-%s", ctx.ChainID.String(), addr0.String()),
+			}},
+			7,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.label, func(t *testing.T) {
+			utxosReply := &GetUTXOsReply{}
+			if err := s.GetUTXOs(nil, tt.args, utxosReply); err != nil {
+				t.Error(err)
+			} else if tt.count != len(utxosReply.UTXOs) {
+				t.Errorf("Expected %d utxos, got %#v", tt.count, len(utxosReply.UTXOs))
+			}
+		})
+	}
+}
+
+func TestGetAssetDescription(t *testing.T) {
+	genesisBytes, vm, s := setup(t)
+	defer ctx.Lock.Unlock()
 	defer vm.Shutdown()
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	avaAssetID := genesisTx.ID()
 
-	s := Service{vm: vm}
-
 	reply := GetAssetDescriptionReply{}
-	err = s.GetAssetDescription(nil, &GetAssetDescriptionArgs{
+	err := s.GetAssetDescription(nil, &GetAssetDescriptionArgs{
 		AssetID: avaAssetID.String(),
 	}, &reply)
 	if err != nil {
@@ -57,35 +211,16 @@ func TestGetAssetDescription(t *testing.T) {
 }
 
 func TestGetBalance(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	ctx.Lock.Lock()
+	genesisBytes, vm, s := setup(t)
 	defer ctx.Lock.Unlock()
-
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		make(chan common.Message, 1),
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
 	defer vm.Shutdown()
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
 
 	avaAssetID := genesisTx.ID()
 
-	s := Service{vm: vm}
-
 	reply := GetBalanceReply{}
-	err = s.GetBalance(nil, &GetBalanceArgs{
+	err := s.GetBalance(nil, &GetBalanceArgs{
 		Address: vm.Format(keys[0].PublicKey().Address().Bytes()),
 		AssetID: avaAssetID.String(),
 	}, &reply)
@@ -99,31 +234,12 @@ func TestGetBalance(t *testing.T) {
 }
 
 func TestCreateFixedCapAsset(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	ctx.Lock.Lock()
+	_, vm, s := setup(t)
 	defer ctx.Lock.Unlock()
-
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		make(chan common.Message, 1),
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
 	defer vm.Shutdown()
 
-	s := Service{vm: vm}
-
 	reply := CreateFixedCapAssetReply{}
-	err = s.CreateFixedCapAsset(nil, &CreateFixedCapAssetArgs{
+	err := s.CreateFixedCapAsset(nil, &CreateFixedCapAssetArgs{
 		Name:         "test asset",
 		Symbol:       "test",
 		Denomination: 1,
@@ -142,31 +258,12 @@ func TestCreateFixedCapAsset(t *testing.T) {
 }
 
 func TestCreateVariableCapAsset(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	ctx.Lock.Lock()
+	_, vm, s := setup(t)
 	defer ctx.Lock.Unlock()
-
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		make(chan common.Message, 1),
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
 	defer vm.Shutdown()
 
-	s := Service{vm: vm}
-
 	reply := CreateVariableCapAssetReply{}
-	err = s.CreateVariableCapAsset(nil, &CreateVariableCapAssetArgs{
+	err := s.CreateVariableCapAsset(nil, &CreateVariableCapAssetArgs{
 		Name:   "test asset",
 		Symbol: "test",
 		MinterSets: []Owners{
diff --git a/vms/avm/state_test.go b/vms/avm/state_test.go
index 212fc18..aac77c1 100644
--- a/vms/avm/state_test.go
+++ b/vms/avm/state_test.go
@@ -15,7 +15,8 @@ import (
 )
 
 func TestStateIDs(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state.state
 
 	id0 := ids.NewID([32]byte{0xff, 0})
@@ -124,7 +125,8 @@ func TestStateIDs(t *testing.T) {
 }
 
 func TestStateStatuses(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state.state
 
 	if _, err := state.Status(ids.Empty); err == nil {
@@ -172,7 +174,8 @@ func TestStateStatuses(t *testing.T) {
 }
 
 func TestStateUTXOs(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state.state
 
 	vm.codec.RegisterType(&ava.TestVerifiable{})
@@ -242,7 +245,8 @@ func TestStateUTXOs(t *testing.T) {
 }
 
 func TestStateTXs(t *testing.T) {
-	vm := GenesisVM(t)
+	_, _, vm := GenesisVM(t)
+	ctx.Lock.Unlock()
 	state := vm.state.state
 
 	vm.codec.RegisterType(&ava.TestTransferable{})
diff --git a/vms/avm/vm_test.go b/vms/avm/vm_test.go
index ef54a18..cfd09e8 100644
--- a/vms/avm/vm_test.go
+++ b/vms/avm/vm_test.go
@@ -154,18 +154,20 @@ func BuildGenesisTest(t *testing.T) []byte {
 	return reply.Bytes.Bytes
 }
 
-func GenesisVM(t *testing.T) *VM {
+func GenesisVM(t *testing.T) ([]byte, chan common.Message, *VM) {
 	genesisBytes := BuildGenesisTest(t)
 
+	// NB: this lock is intentionally left locked when this function returns.
+	// The caller of this function is responsible for unlocking.
 	ctx.Lock.Lock()
-	defer ctx.Lock.Unlock()
 
+	issuer := make(chan common.Message, 1)
 	vm := &VM{}
 	err := vm.Initialize(
 		ctx,
 		memdb.New(),
 		genesisBytes,
-		make(chan common.Message, 1),
+		issuer,
 		[]*common.Fx{&common.Fx{
 			ID: ids.Empty,
 			Fx: &secp256k1fx.Fx{},
@@ -176,7 +178,57 @@ func GenesisVM(t *testing.T) *VM {
 	}
 	vm.batchTimeout = 0
 
-	return vm
+	return genesisBytes, issuer, vm
+}
+
+func NewTx(t *testing.T, genesisBytes []byte, vm *VM) *Tx {
+	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
+
+	newTx := &Tx{UnsignedTx: &BaseTx{
+		NetID: networkID,
+		BCID:  chainID,
+		Ins: []*ava.TransferableInput{&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(&newTx.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)
+
+	newTx.Creds = append(newTx.Creds, &secp256k1fx.Credential{
+		Sigs: [][crypto.SECP256K1RSigLen]byte{
+			fixedSig,
+		},
+	})
+
+	b, err := vm.codec.Marshal(newTx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	newTx.Initialize(b)
+	return newTx
 }
 
 func TestTxSerialization(t *testing.T) {
@@ -404,73 +456,9 @@ type testTxBytes struct{ unsignedBytes []byte }
 func (tx *testTxBytes) UnsignedBytes() []byte { return tx.unsignedBytes }
 
 func TestIssueTx(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
+	genesisBytes, issuer, vm := GenesisVM(t)
 
-	issuer := make(chan common.Message, 1)
-
-	ctx.Lock.Lock()
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		issuer,
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
-
-	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
-
-	newTx := &Tx{UnsignedTx: &BaseTx{
-		NetID: networkID,
-		BCID:  chainID,
-		Ins: []*ava.TransferableInput{&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(&newTx.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)
-
-	newTx.Creds = append(newTx.Creds, &secp256k1fx.Credential{
-		Sigs: [][crypto.SECP256K1RSigLen]byte{
-			fixedSig,
-		},
-	})
-
-	b, err := vm.codec.Marshal(newTx)
-	if err != nil {
-		t.Fatal(err)
-	}
-	newTx.Initialize(b)
+	newTx := NewTx(t, genesisBytes, vm)
 
 	txID, err := vm.IssueTx(newTx.Bytes(), nil)
 	if err != nil {
@@ -492,24 +480,7 @@ func TestIssueTx(t *testing.T) {
 }
 
 func TestGenesisGetUTXOs(t *testing.T) {
-	genesisBytes := BuildGenesisTest(t)
-
-	ctx.Lock.Lock()
-	vm := &VM{}
-	err := vm.Initialize(
-		ctx,
-		memdb.New(),
-		genesisBytes,
-		make(chan common.Message, 1),
-		[]*common.Fx{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
+	_, _, vm := GenesisVM(t)
 
 	shortAddr := keys[0].PublicKey().Address()
 	addr := ids.NewID(hashing.ComputeHash256Array(shortAddr.Bytes()))
@@ -531,26 +502,7 @@ func TestGenesisGetUTXOs(t *testing.T) {
 // Test issuing a transaction that consumes a currently pending UTXO. The
 // transaction should be issued successfully.
 func TestIssueDependentTx(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{&common.Fx{
-			ID: ids.Empty,
-			Fx: &secp256k1fx.Fx{},
-		}},
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vm.batchTimeout = 0
+	genesisBytes, issuer, vm := GenesisVM(t)
 
 	genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)