Enable TestSmeshing

fastnet preset includes wallet template

Makefile-libs.Inc

@@ -160,13 +160,11 @@ get-athena-lib: $(BINDIR_ATHENA_SETUP_LIBS) $(BIN_DIR)$(ATHENA_LIB_RENAMED)
 go-env: get-postrs-lib
 	go env -w CGO_CFLAGS="$(CGO_CFLAGS)"
 	go env -w CGO_LDFLAGS="$(CGO_LDFLAGS)"
-	go env -w ATHENA_LIB_PATH="$(ATHENA_LIB_PATH)"
 .PHONY: go-env
 
 go-env-test: get-postrs-lib
 	go env -w CGO_CFLAGS="$(CGO_CFLAGS)"
 	go env -w CGO_LDFLAGS="$(CGO_TEST_LDFLAGS)"
-	go env -w ATHENA_LIB_PATH="$(ATHENA_LIB_PATH)"
 .PHONY: go-env-test
 
 print-env: get-postrs-lib

config/presets/fastnet.go

@@ -10,6 +10,8 @@ import (
 	"github.com/spacemeshos/go-spacemesh/activation"
 	"github.com/spacemeshos/go-spacemesh/common/types"
 	"github.com/spacemeshos/go-spacemesh/config"
+	"github.com/spacemeshos/go-spacemesh/vm/programs/wallet"
+	walletTemplate "github.com/spacemeshos/go-spacemesh/vm/templates/wallet"
 )
 
 func init() {
@@ -44,7 +46,12 @@ func fastnet() config.Config {
 
 	conf.Genesis = config.GenesisConfig{
 		ExtraData: "fastnet",
-		Accounts:  map[string]uint64{},
+		Accounts: map[string]uint64{
+			walletTemplate.TemplateAddress.StringWithHRP(conf.NetworkHRP): 10000000000000,
+		},
+		Templates: map[string][]byte{
+			walletTemplate.TemplateAddress.StringWithHRP(conf.NetworkHRP): wallet.PROGRAM,
+		},
 	}
 
 	conf.LayerAvgSize = 50

systest/Dockerfile

@@ -40,7 +40,9 @@ COPY --from=build /src/build/test2json /bin/
 COPY --from=build /bin/gotestsum /bin/
 COPY --from=build /src/build/libpost.so /bin/
 COPY --from=build /src/build/post-service /bin/
+COPY --from=build /src/build/libathenavmwrapper.so /bin/
 ENV LD_LIBRARY_PATH="/bin/"
+ENV ATHENA_LIB_PATH="/bin/libathenavmwrapper.so"
 
 ENV GOVERSION=1.23
 ENV GOTESTSUM_FORMAT=standard-quiet

systest/Makefile

@@ -36,7 +36,7 @@ ifeq ($(configname),$(test_job_name))
 	run_deps = config
 endif
 
-command := gotestsum --raw-command -- test2json -t -p systest \
+command := ATHENA_LIB_PATH=/bin/libathenavmwrapper.so gotestsum -f standard-verbose --raw-command -- test2json -t -p systest \
 	/bin/tests -test.v -test.count=$(count) -test.timeout=60m -test.run=$(test_name) -test.parallel=$(clusters) \
 	-test.failfast=$(failfast) -clusters=$(clusters) -level=$(level) -configname=$(configname)
 

systest/tests/common.go

@@ -59,7 +59,8 @@ func sendTransactions(
 			time.Sleep(200 * time.Millisecond)
 			if nonce == 0 {
 				logger.Infow("address needs to be spawned", "account", i)
-				if err := submitSpawn(ctx, cl, i, client); err != nil {
+				if err := submitSpawn(ctx, cl, i, client, logger); err != nil {
+					logger.Errorw("failed to spawn", "i", i, "client", client.Name)
 					return false, fmt.Errorf("failed to spawn %w", err)
 				}
 				nonce++
@@ -77,7 +78,7 @@ func sendTransactions(
 				retries := 3
 				spendClient := client
 				for k := 0; k < retries; k++ {
-					err = submitSpend(ctx, cl, i, receiver, uint64(amount), nonce+uint64(j), spendClient)
+					err = submitSpend(ctx, cl, i, receiver, uint64(amount), nonce+uint64(j), spendClient, logger)
 					if err == nil {
 						break
 					}
@@ -105,11 +106,17 @@ func sendTransactions(
 	return nil
 }
 
-func submitTransaction(ctx context.Context, tx []byte, node *cluster.NodeClient) ([]byte, error) {
+func submitTransaction(
+	ctx context.Context,
+	tx []byte,
+	node *cluster.NodeClient,
+	logger *zap.SugaredLogger,
+) ([]byte, error) {
 	txclient := pb.NewTransactionServiceClient(node.PubConn())
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 	response, err := txclient.SubmitTransaction(ctx, &pb.SubmitTransactionRequest{Transaction: tx})
+	logger.Debugw("submitted transaction", "tx", tx, "response", response, "err", err)
 	if err != nil {
 		return nil, err
 	}
@@ -296,6 +303,68 @@ func waitLayer(ctx *testcontext.Context, node *cluster.NodeClient, lid uint32) e
 	}
 }
 
+func waitTransaction(ctx context.Context,
+	eg *errgroup.Group,
+	client *cluster.NodeClient,
+	id []byte,
+) {
+	eg.Go(func() error {
+		api := pb.NewTransactionServiceClient(client.PubConn())
+		rsts, err := api.StreamResults(ctx, &pb.TransactionResultsRequest{Watch: true, Id: id})
+		if err != nil {
+			return err
+		}
+		_, err = rsts.Recv()
+		if err != nil {
+			return fmt.Errorf("stream error on receiving result %s: %w", client.Name, err)
+		}
+		return nil
+	})
+}
+
+func watchTransactionResults(ctx context.Context,
+	eg *errgroup.Group,
+	client *cluster.NodeClient,
+	log *zap.Logger,
+	collector func(*pb.TransactionResult) (bool, error),
+) {
+	eg.Go(func() error {
+		retries := 0
+	BACKOFF:
+
+		api := pb.NewTransactionServiceClient(client.PubConn())
+		rsts, err := api.StreamResults(ctx, &pb.TransactionResultsRequest{Watch: true})
+		if err != nil {
+			return err
+		}
+		for {
+			rst, err := rsts.Recv()
+			s, ok := status.FromError(err)
+			if ok && s.Code() != codes.OK {
+				log.Warn("transactions stream error",
+					zap.String("client", client.Name),
+					zap.Error(err),
+					zap.Any("status", s),
+				)
+				if s.Code() == codes.Unavailable {
+					if retries == attempts {
+						return errors.New("transaction results unavailable")
+					}
+					retries++
+					time.Sleep(retryBackoff)
+					goto BACKOFF
+				}
+			}
+			if err != nil {
+				return fmt.Errorf("stream error on receiving result %s: %w", client.Name, err)
+			}
+			if cont, err := collector(rst); !cont {
+				return err
+			}
+		}
+	})
+}
+
 func watchProposals(
 	ctx context.Context,
 	eg *errgroup.Group,
@@ -403,15 +472,30 @@ func getNonce(ctx context.Context, client *cluster.NodeClient, address types.Add
 	return resp.AccountWrapper.StateProjected.Counter, nil
 }
 
-func submitSpawn(ctx context.Context, cluster *cluster.Cluster, account int, client *cluster.NodeClient) error {
+func currentBalance(ctx context.Context, client *cluster.NodeClient, address types.Address) (uint64, error) {
+	gstate := pb.NewGlobalStateServiceClient(client.PubConn())
+	resp, err := gstate.Account(ctx, &pb.AccountRequest{AccountId: &pb.AccountId{Address: address.String()}})
+	if err != nil {
+		return 0, err
+	}
+	return resp.AccountWrapper.StateCurrent.Balance.Value, nil
+}
+
+func submitSpawn(
+	ctx context.Context,
+	cluster *cluster.Cluster,
+	account int,
+	client *cluster.NodeClient,
+	logger *zap.SugaredLogger,
+) error {
 	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
 	tx, err := wallet.Spawn(cluster.Private(account), 0, sdk.WithGenesisID(cluster.GenesisID()))
 	if err != nil {
 		return err
 	}
 
-	_, err = submitTransaction(ctx, tx, client)
+	_, err = submitTransaction(ctx, tx, client, logger)
 	return err
 }
 
@@ -422,14 +506,15 @@ func submitSpend(
 	receiver types.Address,
 	amount, nonce uint64,
 	client *cluster.NodeClient,
+	logger *zap.SugaredLogger,
 ) error {
 	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 	defer cancel()
 	tx, err := wallet.Spend(cluster.Private(account), receiver, amount, nonce, sdk.WithGenesisID(cluster.GenesisID()))
 	if err != nil {
 		return err
 	}
-	_, err = submitTransaction(ctx, tx, client)
+	_, err = submitTransaction(ctx, tx, client, logger)
 	return err
 }
 
@@ -490,13 +575,13 @@ func (c *txClient) nonce(ctx context.Context) (uint64, error) {
 	return getNonce(ctx, c.node, c.account.Address)
 }
 
-func (c *txClient) submit(ctx context.Context, tx []byte) (*txRequest, error) {
+func (c *txClient) submit(ctx context.Context, tx []byte, logger *zap.SugaredLogger) (*txRequest, error) {
 	var (
 		txid []byte
 		err  error
 	)
 	for i := 0; i < attempts; i++ {
-		if txid, err = submitTransaction(ctx, tx, c.node); err == nil {
+		if txid, err = submitTransaction(ctx, tx, c.node, logger); err == nil {
 			return &txRequest{
 				node: c.node,
 				txid: txid,