Verified PAID exchange data messages for merchant chats are no longer silent

Author: jeffyanta

pkg/code/async/geyser/external_deposit.go

@@ -265,7 +265,7 @@ func processPotentialExternalDeposit(ctx context.Context, data code_data.Provide
 	if err != nil {
 		return errors.Wrap(err, "error updating cash transactions chat")
 	}
-	err = chat_util.SendMerchantExchangeMessage(ctx, data, intentRecord)
+	_, err = chat_util.SendMerchantExchangeMessage(ctx, data, intentRecord)
 	if err != nil {
 		return errors.Wrap(err, "error updating merchant chat")
 	}

pkg/code/chat/message_merchant.go

@@ -15,12 +15,19 @@ import (
 	"github.com/code-payments/code-server/pkg/code/data/intent"
 )
 
+type MessageWithOwner struct {
+	Owner   *common.Account
+	Title   string
+	Message *chatpb.ChatMessage
+}
+
 // SendMerchantExchangeMessage sends a message to the merchant's chat with
 // exchange data content related to the submitted intent. Intents that
-// don't belong in the merchant chat will be ignored.
+// don't belong in the merchant chat will be ignored. The set of chat messages
+// that should be pushed are returned.
 //
 // Note: Tests covered in SubmitIntent history tests
-func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, intentRecord *intent.Record) error {
+func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, intentRecord *intent.Record) ([]*MessageWithOwner, error) {
 	messageId := intentRecord.IntentId
 
 	// There are three possible chats for a merchant:
@@ -38,7 +45,7 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 
 	exchangeData, ok := getExchangeDataFromIntent(intentRecord)
 	if !ok {
-		return nil
+		return nil, nil
 	}
 
 	verbByMessageReceiver := make(map[string]chatpb.ExchangeDataContent_Verb)
@@ -47,7 +54,7 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 		if intentRecord.SendPrivatePaymentMetadata.IsMicroPayment {
 			paymentRequestRecord, err := data.GetPaymentRequest(ctx, intentRecord.IntentId)
 			if err != nil {
-				return errors.Wrap(err, "error getting payment request record")
+				return nil, errors.Wrap(err, "error getting payment request record")
 			}
 
 			if paymentRequestRecord.Domain != nil {
@@ -64,7 +71,7 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 			if len(intentRecord.SendPrivatePaymentMetadata.DestinationOwnerAccount) > 0 {
 				destinationAccountInfoRecord, err := data.GetAccountInfoByTokenAddress(ctx, intentRecord.SendPrivatePaymentMetadata.DestinationTokenAccount)
 				if err != nil {
-					return err
+					return nil, err
 				} else if destinationAccountInfoRecord.AccountType == commonpb.AccountType_RELATIONSHIP {
 					// Relationship accounts only exist against verified merchants,
 					// and will have merchant payments appear in the verified merchant
@@ -81,7 +88,7 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 			if len(intentRecord.SendPublicPaymentMetadata.DestinationOwnerAccount) > 0 {
 				destinationAccountInfoRecord, err := data.GetAccountInfoByTokenAddress(ctx, intentRecord.SendPublicPaymentMetadata.DestinationTokenAccount)
 				if err != nil {
-					return err
+					return nil, err
 				} else if destinationAccountInfoRecord.AccountType == commonpb.AccountType_RELATIONSHIP {
 					// Relationship accounts only exist against verified merchants,
 					// and will have merchant payments appear in the verified merchant
@@ -97,7 +104,7 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 		messageId = strings.Split(messageId, "-")[0]
 		destinationAccountInfoRecord, err := data.GetAccountInfoByTokenAddress(ctx, intentRecord.ExternalDepositMetadata.DestinationTokenAccount)
 		if err != nil {
-			return err
+			return nil, err
 		} else if destinationAccountInfoRecord.AccountType == commonpb.AccountType_RELATIONSHIP {
 			// Relationship accounts only exist against verified merchants,
 			// and will have merchant payments appear in the verified merchant
@@ -108,13 +115,14 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 			verbByMessageReceiver[intentRecord.ExternalDepositMetadata.DestinationOwnerAccount] = chatpb.ExchangeDataContent_DEPOSITED
 		}
 	default:
-		return nil
+		return nil, nil
 	}
 
+	var messagesToPush []*MessageWithOwner
 	for account, verb := range verbByMessageReceiver {
 		receiver, err := common.NewAccountFromPublicKeyString(account)
 		if err != nil {
-			return err
+			return nil, err
 		}
 
 		content := []*chatpb.Content{
@@ -131,22 +139,30 @@ func SendMerchantExchangeMessage(ctx context.Context, data code_data.Provider, i
 		}
 		protoMessage, err := newProtoChatMessage(messageId, content, intentRecord.CreatedAt)
 		if err != nil {
-			return errors.Wrap(err, "error creating proto chat message")
+			return nil, errors.Wrap(err, "error creating proto chat message")
 		}
 
-		_, err = SendChatMessage(
+		canPush, err := SendChatMessage(
 			ctx,
 			data,
 			chatTitle,
 			chatType,
 			isVerifiedChat,
 			receiver,
 			protoMessage,
-			true,
+			verb != chatpb.ExchangeDataContent_PAID || !isVerifiedChat,
 		)
 		if err != nil && err != chat.ErrMessageAlreadyExists {
-			return errors.Wrap(err, "error persisting chat message")
+			return nil, errors.Wrap(err, "error persisting chat message")
+		}
+
+		if canPush {
+			messagesToPush = append(messagesToPush, &MessageWithOwner{
+				Owner:   receiver,
+				Title:   chatTitle,
+				Message: protoMessage,
+			})
 		}
 	}
-	return nil
+	return messagesToPush, nil
 }

pkg/code/push/notifications.go

@@ -16,10 +16,7 @@ import (
 	"github.com/code-payments/code-server/pkg/code/common"
 	code_data "github.com/code-payments/code-server/pkg/code/data"
 	"github.com/code-payments/code-server/pkg/code/data/chat"
-	"github.com/code-payments/code-server/pkg/code/data/intent"
-	"github.com/code-payments/code-server/pkg/code/data/paymentrequest"
 	"github.com/code-payments/code-server/pkg/code/localization"
-	currency_lib "github.com/code-payments/code-server/pkg/currency"
 	"github.com/code-payments/code-server/pkg/kin"
 	push_lib "github.com/code-payments/code-server/pkg/push"
 )
@@ -153,103 +150,6 @@ func SendGiftCardReturnedPushNotification(
 	)
 }
 
-// SendMicroPaymentReceivedPushNotification sends a push to the destination when
-// someone pays for content through a micro payment.
-func SendMicroPaymentReceivedPushNotification(
-	ctx context.Context,
-	data code_data.Provider,
-	pusher push_lib.Provider,
-	intentRecord *intent.Record,
-	paymentRequestRecord *paymentrequest.Record,
-) error {
-	log := logrus.StandardLogger().WithFields(logrus.Fields{
-		"method": "SendMicroPaymentReceivedPushNotification",
-		"intent": intentRecord.IntentId,
-	})
-
-	var destinationOwnerAccount *common.Account
-	var destinationTokenAccount *common.Account
-	var nativeAmount float64
-	var currency currency_lib.Code
-	var err error
-	switch intentRecord.IntentType {
-	case intent.SendPrivatePayment:
-		if !intentRecord.SendPrivatePaymentMetadata.IsMicroPayment {
-			log.Warn("intent isn't a micro payment")
-			return nil
-		}
-
-		if len(intentRecord.SendPrivatePaymentMetadata.DestinationOwnerAccount) == 0 {
-			return nil
-		}
-
-		destinationTokenAccount, err = common.NewAccountFromPublicKeyString(intentRecord.SendPrivatePaymentMetadata.DestinationTokenAccount)
-		if err != nil {
-			log.WithError(err).Warn("invalid destination token account")
-			return err
-		}
-
-		destinationOwnerAccount, err = common.NewAccountFromPublicKeyString(intentRecord.SendPrivatePaymentMetadata.DestinationOwnerAccount)
-		if err != nil {
-			log.WithError(err).Warn("invalid destination owner account")
-			return err
-		}
-
-		nativeAmount = intentRecord.SendPrivatePaymentMetadata.NativeAmount
-		currency = intentRecord.SendPrivatePaymentMetadata.ExchangeCurrency
-	default:
-		log.Warn("intent type doesn't support micro payments")
-		return nil
-	}
-
-	accountInfoRecord, err := data.GetAccountInfoByTokenAddress(ctx, destinationTokenAccount.PublicKey().ToBase58())
-	if err != nil {
-		log.WithError(err).Warn("failure getting account info record")
-		return errors.Wrap(err, "error getting account info record")
-	}
-
-	var chatId chat.ChatId
-	if accountInfoRecord.AccountType == commonpb.AccountType_RELATIONSHIP {
-		// Relationship accounts can only be paid via micro payment through a
-		// verified flow
-		chatId = chat.GetChatId(*accountInfoRecord.RelationshipTo, destinationOwnerAccount.PublicKey().ToBase58(), true)
-	} else {
-		chatId = chat.GetChatId(chat_util.PaymentsName, destinationOwnerAccount.PublicKey().ToBase58(), false)
-	}
-
-	// Legacy push notification still considers chat mute state
-	//
-	// todo: Proper migration to chat system
-	chatRecord, err := data.GetChatById(ctx, chatId)
-	switch err {
-	case nil:
-		if chatRecord.IsMuted {
-			return nil
-		}
-	case chat.ErrChatNotFound:
-	default:
-		log.WithError(err).Warn("failure getting chat record")
-		return errors.Wrap(err, "error getting chat record")
-	}
-
-	amountArg := getAmountArg(nativeAmount, currency)
-
-	// todo: localized keys
-	title := "Payment Received"
-	body := fmt.Sprintf("Someone bought your content for %s", amountArg)
-	if paymentRequestRecord.IsVerified && paymentRequestRecord.Domain != nil {
-		body = fmt.Sprintf("%s on %s", body, *paymentRequestRecord.Domain)
-	}
-	return sendBasicPushNotificationToOwner(
-		ctx,
-		data,
-		pusher,
-		destinationOwnerAccount,
-		title,
-		body,
-	)
-}
-
 // SendChatMessagePushNotification sends a push notification for chat messages
 func SendChatMessagePushNotification(
 	ctx context.Context,

pkg/code/server/grpc/transaction/v2/intent.go

@@ -22,6 +22,7 @@ import (
 	messagingpb "github.com/code-payments/code-protobuf-api/generated/go/messaging/v1"
 	transactionpb "github.com/code-payments/code-protobuf-api/generated/go/transaction/v2"
 
+	"github.com/code-payments/code-server/pkg/code/chat"
 	chat_util "github.com/code-payments/code-server/pkg/code/chat"
 	"github.com/code-payments/code-server/pkg/code/common"
 	code_data "github.com/code-payments/code-server/pkg/code/data"
@@ -33,6 +34,7 @@ import (
 	"github.com/code-payments/code-server/pkg/code/data/nonce"
 	"github.com/code-payments/code-server/pkg/code/data/timelock"
 	"github.com/code-payments/code-server/pkg/code/data/webhook"
+	"github.com/code-payments/code-server/pkg/code/push"
 	"github.com/code-payments/code-server/pkg/code/transaction"
 	"github.com/code-payments/code-server/pkg/grpc/client"
 	"github.com/code-payments/code-server/pkg/kin"
@@ -798,6 +800,8 @@ func (s *transactionServer) SubmitIntent(streamer transactionpb.Transaction_Subm
 		}
 	}
 
+	var chatMessagesToPush []*chat.MessageWithOwner
+
 	// Save all of the required DB records in one transaction to complete the
 	// intent operation. It's very bad if we end up failing halfway through.
 	//
@@ -883,7 +887,7 @@ func (s *transactionServer) SubmitIntent(streamer transactionpb.Transaction_Subm
 				log.WithError(err).Warn("failure updating cash transaction chat")
 				return err
 			}
-			err = chat_util.SendMerchantExchangeMessage(ctx, s.data, intentRecord)
+			chatMessagesToPush, err = chat_util.SendMerchantExchangeMessage(ctx, s.data, intentRecord)
 			if err != nil {
 				log.WithError(err).Warn("failure updating merchant chat")
 				return err
@@ -944,6 +948,21 @@ func (s *transactionServer) SubmitIntent(streamer transactionpb.Transaction_Subm
 		if err != nil {
 			log.WithError(err).Warn("failure executing intent committed callback handler handler")
 		}
+
+		if len(chatMessagesToPush) > 0 {
+			go func() {
+				for _, chatMessageToPush := range chatMessagesToPush {
+					push.SendChatMessagePushNotification(
+						context.TODO(),
+						s.data,
+						s.pusher,
+						chatMessageToPush.Title,
+						chatMessageToPush.Owner,
+						chatMessageToPush.Message,
+					)
+				}
+			}()
+		}
 	}
 
 	// Fire off some success metrics

pkg/code/server/grpc/transaction/v2/intent_handler.go

@@ -961,15 +961,6 @@ func (h *SendPrivatePaymentIntentHandler) OnSaveToDB(ctx context.Context, intent
 }
 
 func (h *SendPrivatePaymentIntentHandler) OnCommittedToDB(ctx context.Context, intentRecord *intent.Record) error {
-	if intentRecord.SendPrivatePaymentMetadata.IsMicroPayment {
-		go bestEffortMicroPaymentPostProcessingJob(
-			h.data,
-			h.pusher,
-			intentRecord,
-			h.cachedPaymentRequestRequest,
-		)
-	}
-
 	return nil
 }
 

pkg/code/server/grpc/transaction/v2/micro_payment.go

@@ -374,7 +374,8 @@ func (s *serverTestEnv) simulateExternalDepositHistoryItem(t *testing.T, owner,
 	require.NoError(t, s.data.SaveIntent(s.ctx, intentRecord))
 
 	require.NoError(t, chat_util.SendCashTransactionsExchangeMessage(s.ctx, s.data, intentRecord))
-	require.NoError(t, chat_util.SendMerchantExchangeMessage(s.ctx, s.data, intentRecord))
+	_, err := chat_util.SendMerchantExchangeMessage(s.ctx, s.data, intentRecord)
+	require.NoError(t, err)
 }
 
 func (s *serverTestEnv) simulateAllCommitmentsUpgraded(t *testing.T) {