Merge pull request #351 from kaleido-io/tokens-op-fail

on transfer/mint/burn fail, set transaction & operation as failed

internal/assets/token_transfer.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 
 	"github.com/hyperledger/firefly/internal/i18n"
+	"github.com/hyperledger/firefly/internal/log"
 	"github.com/hyperledger/firefly/internal/sysmessaging"
 	"github.com/hyperledger/firefly/internal/txcommon"
 	"github.com/hyperledger/firefly/pkg/database"
@@ -298,14 +299,35 @@ func (s *transferSender) sendInternal(ctx context.Context, method sendMethod) er
 
 	switch s.transfer.Type {
 	case fftypes.TokenTransferTypeMint:
-		return plugin.MintTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
+		err = plugin.MintTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
 	case fftypes.TokenTransferTypeTransfer:
-		return plugin.TransferTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
+		err = plugin.TransferTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
 	case fftypes.TokenTransferTypeBurn:
-		return plugin.BurnTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
+		err = plugin.BurnTokens(ctx, op.ID, pool.ProtocolID, &s.transfer.TokenTransfer)
 	default:
 		panic(fmt.Sprintf("unknown transfer type: %v", s.transfer.Type))
 	}
+
+	// if transaction fails,  mark tx and op as failed in DB
+	if err != nil {
+		_ = s.mgr.database.RunAsGroup(ctx, func(ctx context.Context) (err error) {
+			l := log.L(ctx)
+			tx.Status = fftypes.OpStatusFailed
+
+			update := database.OperationQueryFactory.NewUpdate(ctx).
+				Set("status", fftypes.OpStatusFailed)
+			if err = s.mgr.database.UpdateTransaction(ctx, tx.ID, update); err != nil {
+				l.Errorf("TX update failed: %s update=[ %s ]", err, update)
+			}
+			if err = s.mgr.database.UpdateOperation(ctx, op.ID, update); err != nil {
+				l.Errorf("Operation update failed: %s update=[ %s ]", err, update)
+			}
+
+			return nil
+		})
+	}
+
+	return err
 }
 
 func (s *transferSender) buildTransferMessage(ctx context.Context, ns string, in *fftypes.MessageInOut) (sysmessaging.MessageSender, error) {

internal/assets/token_transfer_test.go

@@ -454,6 +454,40 @@ func TestMintTokensFail(t *testing.T) {
 		return tx.Subject.Type == fftypes.TransactionTypeTokenTransfer
 	}), false).Return(nil)
 	mdi.On("UpsertOperation", context.Background(), mock.Anything, false).Return(nil)
+	mdi.On("UpdateTransaction", context.Background(), mock.Anything, mock.Anything).Return(nil)
+	mdi.On("UpdateOperation", context.Background(), mock.Anything, mock.Anything).Return(nil)
+
+	_, err := am.MintTokens(context.Background(), "ns1", mint, false)
+	assert.EqualError(t, err, "pop")
+}
+
+func TestMintTokensFailAndDbFail(t *testing.T) {
+	am, cancel := newTestAssets(t)
+	defer cancel()
+
+	mint := &fftypes.TokenTransferInput{
+		TokenTransfer: fftypes.TokenTransfer{
+			Amount: *fftypes.NewBigInt(5),
+		},
+		Pool: "pool1",
+	}
+	pool := &fftypes.TokenPool{
+		ProtocolID: "F1",
+		State:      fftypes.TokenPoolStateConfirmed,
+	}
+
+	mdi := am.database.(*databasemocks.Plugin)
+	mti := am.tokens["magic-tokens"].(*tokenmocks.Plugin)
+	mim := am.identity.(*identitymanagermocks.Manager)
+	mim.On("GetLocalOrganization", context.Background()).Return(&fftypes.Organization{Identity: "0x12345"}, nil)
+	mdi.On("GetTokenPool", context.Background(), "ns1", "pool1").Return(pool, nil)
+	mti.On("MintTokens", context.Background(), mock.Anything, "F1", &mint.TokenTransfer).Return(fmt.Errorf("pop"))
+	mdi.On("UpsertOperation", context.Background(), mock.Anything, false).Return(nil)
+	mdi.On("UpsertTransaction", context.Background(), mock.MatchedBy(func(tx *fftypes.Transaction) bool {
+		return tx.Subject.Type == fftypes.TransactionTypeTokenTransfer && tx.Status != fftypes.OpStatusFailed
+	}), false).Return(nil)
+	mdi.On("UpdateTransaction", context.Background(), mock.Anything, mock.Anything).Return(fmt.Errorf("Update fail"))
+	mdi.On("UpdateOperation", context.Background(), mock.Anything, mock.Anything).Return(fmt.Errorf("Update fail"))
 
 	_, err := am.MintTokens(context.Background(), "ns1", mint, false)
 	assert.EqualError(t, err, "pop")