Merge pull request 'ui-cleanup-update' (#104) from ui-cleanup-update into master

Reviewed-on: #104

handlers/application/send.go

@@ -10,183 +10,132 @@ import (
 	"git.defalsify.org/vise.git/resource"
 	"git.grassecon.net/grassrootseconomics/common/identity"
 	"git.grassecon.net/grassrootseconomics/common/phone"
+	"git.grassecon.net/grassrootseconomics/sarafu-api/models"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
 	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
 	"github.com/grassrootseconomics/ethutils"
-	dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
 	"gopkg.in/leonelquinteros/gotext.v1"
 )
 
 // ValidateRecipient validates that the given input is valid.
+//
+// TODO: split up functino
 func (h *MenuHandlers) ValidateRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
+	var AliasAddressResult string
+	var AliasAddress *models.AliasAddress
 	store := h.userdataStore
-	flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
 
 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}
+	flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
+	flag_invalid_recipient_with_invite, _ := h.flagManager.GetFlag("flag_invalid_recipient_with_invite")
+	flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
 
 	// remove white spaces
 	recipient := strings.ReplaceAll(string(input), " ", "")
-	if recipient == "0" {
-		return res, nil
-	}
 
-	recipientType, err := identity.CheckRecipient(recipient)
+	if recipient != "0" {
-	if err != nil {
+		recipientType, err := identity.CheckRecipient(recipient)
-		// Invalid recipient format (not a phone number, address, or valid alias format)
+		if err != nil {
-		res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
+			// Invalid recipient format (not a phone number, address, or valid alias format)
-		res.Content = recipient
+			res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
-
-		return res, nil
-	}
-
-	// save the recipient as the temporaryRecipient
-	err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(recipient))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write temporaryRecipient entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", recipient, "error", err)
-		return res, err
-	}
-
-	switch recipientType {
-	case "phone number":
-		return h.handlePhoneNumber(ctx, sessionId, recipient, &res)
-	case "address":
-		return h.handleAddress(ctx, sessionId, recipient, &res)
-	case "alias":
-		return h.handleAlias(ctx, sessionId, recipient, &res)
-	}
-
-	return res, nil
-}
-
-func (h *MenuHandlers) handlePhoneNumber(ctx context.Context, sessionId, recipient string, res *resource.Result) (resource.Result, error) {
-	store := h.userdataStore
-	flag_invalid_recipient_with_invite, _ := h.flagManager.GetFlag("flag_invalid_recipient_with_invite")
-
-	formattedNumber, err := phone.FormatPhoneNumber(recipient)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "Failed to format phone number", "recipient", recipient, "error", err)
-		return *res, err
-	}
-
-	publicKey, err := store.ReadEntry(ctx, formattedNumber, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		if db.IsNotFound(err) {
-			logg.InfoCtxf(ctx, "Unregistered phone number", "recipient", recipient)
-			res.FlagSet = append(res.FlagSet, flag_invalid_recipient_with_invite)
 			res.Content = recipient
-			return *res, nil
+
+			return res, nil
 		}
-		logg.ErrorCtxf(ctx, "Failed to read publicKey", "error", err)
-		return *res, err
-	}
 
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, publicKey); err != nil {
+		// save the recipient as the temporaryRecipient
-		logg.ErrorCtxf(ctx, "Failed to write recipient", "value", string(publicKey), "error", err)
+		err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(recipient))
-		return *res, err
+		if err != nil {
-	}
+			logg.ErrorCtxf(ctx, "failed to write temporaryRecipient entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", recipient, "error", err)
-
+			return res, err
-	senderActiveAddress, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "Failed to read sender senderActiveAddress", "error", err)
-		return *res, err
-	}
-
-	recipientActiveAddress, _ := store.ReadEntry(ctx, formattedNumber, storedb.DATA_ACTIVE_ADDRESS)
-
-	txType := "swap"
-
-	// recipient has no active token → normal transaction
-	if recipientActiveAddress == nil {
-		txType = "normal"
-	} else if senderActiveAddress != nil && string(senderActiveAddress) == string(recipientActiveAddress) {
-		// recipient has active token same as sender → normal transaction
-		txType = "normal"
-	}
-
-	// save transaction type
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE, []byte(txType)); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to write tx type", "type", txType, "error", err)
-		return *res, err
-	}
-
-	// save the recipient's phone number
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT_PHONE_NUMBER, []byte(formattedNumber)); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to write recipient's phone number", "type", txType, "error", err)
-		return *res, err
-	}
-
-	return *res, nil
-}
-
-func (h *MenuHandlers) handleAddress(ctx context.Context, sessionId, recipient string, res *resource.Result) (resource.Result, error) {
-	store := h.userdataStore
-
-	address := ethutils.ChecksumAddress(recipient)
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(address)); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to write recipient address", "error", err)
-		return *res, err
-	}
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE, []byte("normal")); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to write tx type for address", "error", err)
-		return *res, err
-	}
-
-	return *res, nil
-}
-
-func (h *MenuHandlers) handleAlias(ctx context.Context, sessionId, recipient string, res *resource.Result) (resource.Result, error) {
-	store := h.userdataStore
-	flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
-	flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
-
-	var AliasAddressResult string
-
-	if strings.Contains(recipient, ".") {
-		alias, err := h.accountService.CheckAliasAddress(ctx, recipient)
-		if err == nil {
-			AliasAddressResult = alias.Address
-		} else {
-			logg.ErrorCtxf(ctx, "Failed to resolve alias", "alias", recipient, "error", err)
 		}
-	} else {
-		for _, domain := range config.SearchDomains() {
-			fqdn := fmt.Sprintf("%s.%s", recipient, domain)
-			logg.InfoCtxf(ctx, "Trying alias", "fqdn", fqdn)
 
-			alias, err := h.accountService.CheckAliasAddress(ctx, fqdn)
+		switch recipientType {
-			if err == nil {
+		case "phone number":
-				res.FlagReset = append(res.FlagReset, flag_api_error)
+			// format the phone number
-				AliasAddressResult = alias.Address
+			formattedNumber, err := phone.FormatPhoneNumber(recipient)
-				break
+			if err != nil {
+				logg.ErrorCtxf(ctx, "Failed to format the phone number: %s", recipient, "error", err)
+				return res, err
+			}
+
+			// Check if the phone number is registered
+			publicKey, err := store.ReadEntry(ctx, formattedNumber, storedb.DATA_PUBLIC_KEY)
+			if err != nil {
+				if db.IsNotFound(err) {
+					logg.InfoCtxf(ctx, "Unregistered phone number: %s", recipient)
+					res.FlagSet = append(res.FlagSet, flag_invalid_recipient_with_invite)
+					res.Content = recipient
+					return res, nil
+				}
+
+				logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
+				return res, err
+			}
+
+			// Save the publicKey as the recipient
+			err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, publicKey)
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write recipient entry with", "key", storedb.DATA_RECIPIENT, "value", string(publicKey), "error", err)
+				return res, err
+			}
+
+		case "address":
+			// checksum the address
+			address := ethutils.ChecksumAddress(recipient)
+
+			// Save the valid Ethereum address as the recipient
+			err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(address))
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write recipient entry with", "key", storedb.DATA_RECIPIENT, "value", recipient, "error", err)
+				return res, err
+			}
+
+		case "alias":
+			if strings.Contains(recipient, ".") {
+				AliasAddress, err = h.accountService.CheckAliasAddress(ctx, recipient)
+				if err == nil {
+					AliasAddressResult = AliasAddress.Address
+				} else {
+					logg.ErrorCtxf(ctx, "failed to resolve alias", "alias", recipient, "error_alias_check", err)
+				}
 			} else {
-				res.FlagSet = append(res.FlagSet, flag_api_error)
+				//Perform a search for each search domain,break on first match
-				logg.ErrorCtxf(ctx, "Alias resolution failed", "alias", fqdn, "error", err)
+				for _, domain := range config.SearchDomains() {
-				return *res, nil
+					fqdn := fmt.Sprintf("%s.%s", recipient, domain)
+					logg.InfoCtxf(ctx, "Resolving with fqdn alias", "alias", fqdn)
+					AliasAddress, err = h.accountService.CheckAliasAddress(ctx, fqdn)
+					if err == nil {
+						res.FlagReset = append(res.FlagReset, flag_api_error)
+						AliasAddressResult = AliasAddress.Address
+						continue
+					} else {
+						res.FlagSet = append(res.FlagSet, flag_api_error)
+						logg.ErrorCtxf(ctx, "failed to resolve alias", "alias", recipient, "error_alias_check", err)
+						return res, nil
+					}
+				}
+			}
+			if AliasAddressResult == "" {
+				res.Content = recipient
+				res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
+				return res, nil
+			} else {
+				err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(AliasAddressResult))
+				if err != nil {
+					logg.ErrorCtxf(ctx, "failed to write recipient entry with", "key", storedb.DATA_RECIPIENT, "value", AliasAddressResult, "error", err)
+					return res, err
+				}
 			}
 		}
 	}
 
-	if AliasAddressResult == "" {
+	return res, nil
-		res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
-		res.Content = recipient
-		return *res, nil
-	}
-
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT, []byte(AliasAddressResult)); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to store alias recipient", "error", err)
-		return *res, err
-	}
-	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE, []byte("normal")); err != nil {
-		logg.ErrorCtxf(ctx, "Failed to write tx type for alias", "error", err)
-		return *res, err
-	}
-
-	return *res, nil
 }
 
 // TransactionReset resets the previous transaction data (Recipient and Amount)
@@ -213,16 +162,6 @@ func (h *MenuHandlers) TransactionReset(ctx context.Context, sym string, input [
 		return res, nil
 	}
 
-	err = store.WriteEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE, []byte(""))
-	if err != nil {
-		return res, nil
-	}
-
-	err = store.WriteEntry(ctx, sessionId, storedb.DATA_RECIPIENT_PHONE_NUMBER, []byte(""))
-	if err != nil {
-		return res, nil
-	}
-
 	res.FlagReset = append(res.FlagReset, flag_invalid_recipient, flag_invalid_recipient_with_invite)
 
 	return res, nil
@@ -250,192 +189,29 @@ func (h *MenuHandlers) ResetTransactionAmount(ctx context.Context, sym string, i
 	return res, nil
 }
 
-// MaxAmount checks the transaction type to determine the displayed max amount.
+// MaxAmount gets the current balance from the API and sets it as
-// If the transaction type is "swap", it checks the max swappable amount and sets this as the content.
-// If the transaction type is "normal", gets the current sender's balance from the store and sets it as
 // the result content.
 func (h *MenuHandlers) MaxAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
+	var err error
 
 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}
+	store := h.userdataStore
 
-	flag_api_error, _ := h.flagManager.GetFlag("flag_api_error")
+	activeBal, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
-	flag_swap_transaction, _ := h.flagManager.GetFlag("flag_swap_transaction")
-	userStore := h.userdataStore
-
-	// Fetch session data
-	transactionType, activeBal, activeSym, activeAddress, publicKey, activeDecimal, err := h.getSessionData(ctx, sessionId)
 	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", storedb.DATA_ACTIVE_BAL, "error", err)
 		return res, err
 	}
 
-	// Format the active balance amount to 2 decimal places
+	res.Content = string(activeBal)
-	formattedBalance, _ := store.TruncateDecimalString(string(activeBal), 2)
 
-	// If normal transaction, return balance
-	if string(transactionType) == "normal" {
-		res.FlagReset = append(res.FlagReset, flag_swap_transaction)
-		res.Content = fmt.Sprintf("%s %s", formattedBalance, string(activeSym))
-		return res, nil
-	}
-
-	res.FlagSet = append(res.FlagSet, flag_swap_transaction)
-
-	// Get the recipient's phone number to read other data items
-	recipientPhoneNumber, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT_PHONE_NUMBER)
-	if err != nil {
-		// invalid state
-		return res, err
-	}
-	recipientActiveSym, recipientActiveAddress, recipientActiveDecimal, err := h.getRecipientData(ctx, string(recipientPhoneNumber))
-	if err != nil {
-		return res, err
-	}
-
-	// Resolve active pool address
-	activePoolAddress, err := h.resolveActivePoolAddress(ctx, sessionId)
-	if err != nil {
-		return res, err
-	}
-
-	// Check if sender token is swappable
-	canSwap, err := h.accountService.CheckTokenInPool(ctx, string(activePoolAddress), string(activeAddress))
-	if err != nil || !canSwap.CanSwapFrom {
-		if err != nil {
-			res.FlagSet = append(res.FlagSet, flag_api_error)
-			logg.ErrorCtxf(ctx, "failed on CheckTokenInPool", "error", err)
-		}
-		res.Content = fmt.Sprintf("%s %s", formattedBalance, string(activeSym))
-		return res, err
-	}
-
-	// Calculate max swappable amount
-	maxStr, err := h.calculateSwapMaxAmount(ctx, activePoolAddress, activeAddress, recipientActiveAddress, publicKey, activeDecimal)
-	if err != nil {
-		res.FlagSet = append(res.FlagSet, flag_api_error)
-		return res, err
-	}
-
-	// Fallback if below minimum
-	maxFloat, _ := strconv.ParseFloat(maxStr, 64)
-	if maxFloat < 0.1 {
-		res.Content = fmt.Sprintf("%s %s", formattedBalance, string(activeSym))
-		return res, nil
-	}
-
-	// Save max swap amount and return
-	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SWAP_MAX_AMOUNT, []byte(maxStr))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write swap max amount", "value", maxStr, "error", err)
-		return res, err
-	}
-
-	// save swap related data for the swap preview
-	metadata := &dataserviceapi.TokenHoldings{
-		TokenSymbol:   string(recipientActiveSym),
-		Balance:       formattedBalance, //not used
-		TokenDecimals: string(recipientActiveDecimal),
-		TokenAddress:  string(recipientActiveAddress),
-	}
-
-	// Store the active swap_to data
-	if err := store.UpdateSwapToVoucherData(ctx, userStore, sessionId, metadata); err != nil {
-		logg.ErrorCtxf(ctx, "failed on UpdateSwapToVoucherData", "error", err)
-		return res, err
-	}
-
-	res.Content = fmt.Sprintf("%s %s", maxStr, string(activeSym))
 	return res, nil
 }
 
-func (h *MenuHandlers) getSessionData(ctx context.Context, sessionId string) (transactionType, activeBal, activeSym, activeAddress, publicKey, activeDecimal []byte, err error) {
-	store := h.userdataStore
-
-	transactionType, err = store.ReadEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE)
-	if err != nil {
-		return
-	}
-	activeBal, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
-	if err != nil {
-		return
-	}
-	activeAddress, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
-	if err != nil {
-		return
-	}
-	activeSym, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
-	if err != nil {
-		return
-	}
-	publicKey, err = store.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		return
-	}
-	activeDecimal, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_DECIMAL)
-	if err != nil {
-		return
-	}
-	return
-}
-
-func (h *MenuHandlers) getRecipientData(ctx context.Context, sessionId string) (recipientActiveSym, recipientActiveAddress, recipientActiveDecimal []byte, err error) {
-	store := h.userdataStore
-
-	recipientActiveSym, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
-	if err != nil {
-		return
-	}
-	recipientActiveAddress, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
-	if err != nil {
-		return
-	}
-	recipientActiveDecimal, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_DECIMAL)
-	if err != nil {
-		return
-	}
-	return
-}
-
-func (h *MenuHandlers) resolveActivePoolAddress(ctx context.Context, sessionId string) ([]byte, error) {
-	store := h.userdataStore
-	addr, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_POOL_ADDRESS)
-	if err == nil {
-		return addr, nil
-	}
-	if db.IsNotFound(err) {
-		defaultAddr := []byte(config.DefaultPoolAddress())
-		if err := store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_POOL_ADDRESS, defaultAddr); err != nil {
-			logg.ErrorCtxf(ctx, "failed to write default pool address", "error", err)
-			return nil, err
-		}
-		return defaultAddr, nil
-	}
-	logg.ErrorCtxf(ctx, "failed to read active pool address", "error", err)
-	return nil, err
-}
-
-func (h *MenuHandlers) calculateSwapMaxAmount(ctx context.Context, poolAddress, fromAddress, toAddress, publicKey, decimal []byte) (string, error) {
-	swapLimit, err := h.accountService.GetSwapFromTokenMaxLimit(
-		ctx,
-		string(poolAddress),
-		string(fromAddress),
-		string(toAddress),
-		string(publicKey),
-	)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed on GetSwapFromTokenMaxLimit", "error", err)
-		return "", err
-	}
-
-	scaled := store.ScaleDownBalance(swapLimit.Max, string(decimal))
-
-	formattedAmount, _ := store.TruncateDecimalString(string(scaled), 2)
-	return formattedAmount, nil
-}
-
 // ValidateAmount ensures that the given input is a valid amount and that
 // it is not more than the current balance.
 func (h *MenuHandlers) ValidateAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
@@ -507,7 +283,7 @@ func (h *MenuHandlers) GetRecipient(ctx context.Context, sym string, input []byt
 	recipient, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
 	if len(recipient) == 0 {
 		logg.ErrorCtxf(ctx, "recipient is empty", "key", storedb.DATA_TEMPORARY_VALUE)
-		return res, fmt.Errorf("data error encountered")
+		return res, fmt.Errorf("Data error encountered")
 	}
 
 	res.Content = string(recipient)
@@ -602,185 +378,3 @@ func (h *MenuHandlers) InitiateTransaction(ctx context.Context, sym string, inpu
 	res.FlagReset = append(res.FlagReset, flag_account_authorized)
 	return res, nil
 }
-
-// TransactionSwapPreview displays the send swap preview and estimates
-func (h *MenuHandlers) TransactionSwapPreview(ctx context.Context, sym string, input []byte) (resource.Result, error) {
-	var res resource.Result
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return res, fmt.Errorf("missing session")
-	}
-
-	inputStr := string(input)
-	if inputStr == "0" {
-		return res, nil
-	}
-
-	flag_invalid_amount, _ := h.flagManager.GetFlag("flag_invalid_amount")
-
-	code := codeFromCtx(ctx)
-	l := gotext.NewLocale(translationDir, code)
-	l.AddDomain("default")
-
-	userStore := h.userdataStore
-
-	recipientPhoneNumber, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT_PHONE_NUMBER)
-	if err != nil {
-		// invalid state
-		return res, err
-	}
-
-	swapData, err := store.ReadSwapPreviewData(ctx, userStore, sessionId)
-	if err != nil {
-		return res, err
-	}
-
-	maxValue, err := strconv.ParseFloat(swapData.ActiveSwapMaxAmount, 64)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "Failed to convert the swapMaxAmount to a float", "error", err)
-		return res, err
-	}
-
-	inputAmount, err := strconv.ParseFloat(inputStr, 64)
-	if err != nil || inputAmount > maxValue {
-		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
-		res.Content = inputStr
-		return res, nil
-	}
-
-	// Format the amount to 2 decimal places
-	formattedAmount, err := store.TruncateDecimalString(inputStr, 2)
-	if err != nil {
-		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
-		res.Content = inputStr
-		return res, nil
-	}
-
-	finalAmountStr, err := store.ParseAndScaleAmount(formattedAmount, swapData.ActiveSwapFromDecimal)
-	if err != nil {
-		return res, err
-	}
-
-	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SWAP_AMOUNT, []byte(finalAmountStr))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write swap amount entry with", "key", storedb.DATA_ACTIVE_SWAP_AMOUNT, "value", finalAmountStr, "error", err)
-		return res, err
-	}
-	// store the user's input amount in the temporary value
-	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(inputStr))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write swap amount entry with", "key", storedb.DATA_ACTIVE_SWAP_AMOUNT, "value", finalAmountStr, "error", err)
-		return res, err
-	}
-
-	// call the API to get the quote
-	r, err := h.accountService.GetPoolSwapQuote(ctx, finalAmountStr, swapData.PublicKey, swapData.ActiveSwapFromAddress, swapData.ActivePoolAddress, swapData.ActiveSwapToAddress)
-	if err != nil {
-		flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
-		res.FlagSet = append(res.FlagSet, flag_api_error)
-		res.Content = l.Get("Your request failed. Please try again later.")
-		logg.ErrorCtxf(ctx, "failed on poolSwap", "error", err)
-		return res, nil
-	}
-
-	// Scale down the quoted amount
-	quoteAmountStr := store.ScaleDownBalance(r.OutValue, swapData.ActiveSwapToDecimal)
-
-	fmt.Println("the quoteAmountStr is:", quoteAmountStr)
-	qouteAmount, err := strconv.ParseFloat(quoteAmountStr, 64)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to parse quoteAmountStr as float", "value", quoteAmountStr, "error", err)
-		return res, err
-	}
-
-	// Format to 2 decimal places
-	qouteStr := fmt.Sprintf("%.2f", qouteAmount)
-
-	res.Content = fmt.Sprintf(
-		"%s will receive %s %s",
-		string(recipientPhoneNumber), qouteStr, swapData.ActiveSwapToSym,
-	)
-
-	return res, nil
-}
-
-// TransactionInitiateSwap calls the poolSwap and returns a confirmation based on the result.
-func (h *MenuHandlers) TransactionInitiateSwap(ctx context.Context, sym string, input []byte) (resource.Result, error) {
-	var res resource.Result
-	var err error
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return res, fmt.Errorf("missing session")
-	}
-
-	flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
-	flag_swap_transaction, _ := h.flagManager.GetFlag("flag_swap_transaction")
-
-	code := codeFromCtx(ctx)
-	l := gotext.NewLocale(translationDir, code)
-	l.AddDomain("default")
-
-	userStore := h.userdataStore
-
-	swapData, err := store.ReadSwapPreviewData(ctx, userStore, sessionId)
-	if err != nil {
-		return res, err
-	}
-
-	swapAmount, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SWAP_AMOUNT)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read swapAmount entry with", "key", storedb.DATA_ACTIVE_SWAP_AMOUNT, "error", err)
-		return res, err
-	}
-
-	swapAmountStr := string(swapAmount)
-
-	// Call the poolSwap API
-	poolSwap, err := h.accountService.PoolSwap(ctx, swapAmountStr, swapData.PublicKey, swapData.ActiveSwapFromAddress, swapData.ActivePoolAddress, swapData.ActiveSwapToAddress)
-	if err != nil {
-		flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
-		res.FlagSet = append(res.FlagSet, flag_api_error)
-		res.Content = l.Get("Your request failed. Please try again later.")
-		logg.ErrorCtxf(ctx, "failed on poolSwap", "error", err)
-		return res, nil
-	}
-
-	swapTrackingId := poolSwap.TrackingId
-	logg.InfoCtxf(ctx, "poolSwap", "swapTrackingId", swapTrackingId)
-
-	// Initiate a send 
-	recipientPublicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read swapAmount entry with", "key", storedb.DATA_ACTIVE_SWAP_AMOUNT, "error", err)
-		return res, err
-	}
-	recipientPhoneNumber, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_RECIPIENT_PHONE_NUMBER)
-	if err != nil {
-		// invalid state
-		return res, err
-	}
-
-	// Call TokenTransfer
-	tokenTransfer, err := h.accountService.TokenTransfer(ctx, swapAmountStr, swapData.PublicKey, string(recipientPublicKey), swapData.ActiveSwapToAddress)
-	if err != nil {
-		flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
-		res.FlagSet = append(res.FlagSet, flag_api_error)
-		res.Content = l.Get("Your request failed. Please try again later.")
-		logg.ErrorCtxf(ctx, "failed on TokenTransfer", "error", err)
-		return res, nil
-	}
-
-	trackingId := tokenTransfer.TrackingId
-	logg.InfoCtxf(ctx, "TokenTransfer", "trackingId", trackingId)
-
-	res.Content = l.Get(
-		"Your request has been sent. %s will receive %s %s from %s.",
-		string(recipientPhoneNumber),
-		swapData.TemporaryValue,
-		swapData.ActiveSwapToSym,
-		sessionId,
-	)
-
-	res.FlagReset = append(res.FlagReset, flag_account_authorized, flag_swap_transaction)
-	return res, nil
-}

handlers/application/vouchers.go

@@ -289,8 +289,11 @@ func (h *MenuHandlers) GetVoucherDetails(ctx context.Context, sym string, input
 	}
 	res.FlagReset = append(res.FlagReset, flag_api_error)
 
+	// sanitize invalid characters
+	symbol := strings.ReplaceAll(voucherData.TokenSymbol, "USD₮", "USDT")
+
 	res.Content = fmt.Sprintf(
-		"Name: %s\nSymbol: %s\nCommodity: %s\nLocation: %s", voucherData.TokenName, voucherData.TokenSymbol, voucherData.TokenCommodity, voucherData.TokenLocation,
+		"Name: %s\nSymbol: %s\nProduct: %s\nLocation: %s", voucherData.TokenName, symbol, voucherData.TokenCommodity, voucherData.TokenLocation,
 	)
 
 	return res, nil

handlers/application/vouchers_test.go

@@ -272,7 +272,7 @@ func TestGetVoucherDetails(t *testing.T) {
 		TokenCommodity: "Farming",
 	}
 	expectedResult.Content = fmt.Sprintf(
-		"Name: %s\nSymbol: %s\nCommodity: %s\nLocation: %s", tokenDetails.TokenName, tokenDetails.TokenSymbol, tokenDetails.TokenCommodity, tokenDetails.TokenLocation,
+		"Name: %s\nSymbol: %s\nProduct: %s\nLocation: %s", tokenDetails.TokenName, tokenDetails.TokenSymbol, tokenDetails.TokenCommodity, tokenDetails.TokenLocation,
 	)
 	mockAccountService.On("VoucherData", string(tokA_AAddress)).Return(tokenDetails, nil)
 	res, err := h.GetVoucherDetails(ctx, "SessionId", []byte(""))

handlers/local.go

@@ -136,9 +136,6 @@ func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService)
 	ls.DbRs.AddLocalFunc("swap_max_limit", appHandlers.SwapMaxLimit)
 	ls.DbRs.AddLocalFunc("swap_preview", appHandlers.SwapPreview)
 	ls.DbRs.AddLocalFunc("initiate_swap", appHandlers.InitiateSwap)
-	ls.DbRs.AddLocalFunc("transaction_swap_preview", appHandlers.TransactionSwapPreview)
-	ls.DbRs.AddLocalFunc("transaction_initiate_swap", appHandlers.TransactionInitiateSwap)
-
 	ls.first = appHandlers.Init
 
 	return appHandlers, nil

services/registration/amount.vis

@@ -4,7 +4,6 @@ RELOAD max_amount
 MAP max_amount
 MOUT back 0
 HALT
-CATCH transaction_swap flag_swap_transaction 1
 LOAD validate_amount 64
 RELOAD validate_amount
 CATCH api_failure flag_api_call_error 1

services/registration/pp.csv

@@ -35,4 +35,3 @@ flag,flag_account_pin_reset,41,this is set on an account when an admin triggers
 flag,flag_incorrect_pool,42,this is set when the user selects an invalid pool
 flag,flag_low_swap_amount,43,this is set when the swap max limit is less than 0.1
 flag,flag_alias_unavailable,44,this is set when the preferred alias is not available
-flag,flag_swap_transaction,45,this is set when the transaction will involve performing a swap

services/registration/transaction_swap

@@ -1,3 +0,0 @@
-{{.transaction_swap_preview}}
-
-Please enter your PIN to confirm:

services/registration/transaction_swap.vis

@@ -1,12 +0,0 @@
-LOAD transaction_swap_preview 0
-MAP transaction_swap_preview
-CATCH api_failure flag_api_call_error 1
-MOUT back 0
-MOUT quit 9
-LOAD authorize_account 6
-HALT
-RELOAD authorize_account
-CATCH incorrect_pin flag_incorrect_pin 1
-INCMP _ 0
-INCMP quit 9
-INCMP transaction_swap_initiated *

services/registration/transaction_swap_initiated.vis

@@ -1,4 +0,0 @@
-LOAD reset_incorrect_pin 6
-CATCH _ flag_account_authorized 0
-LOAD transaction_initiate_swap 0
-HALT

store/db/db.go

@@ -89,10 +89,6 @@ const (
 	DATA_ACTIVE_POOL_NAME
 	// Holds the active pool symbol for the swap
 	DATA_ACTIVE_POOL_SYM
-	// Holds the send transaction type
-	DATA_SEND_TRANSACTION_TYPE
-	// Holds the recipient formatted phone number
-	DATA_RECIPIENT_PHONE_NUMBER
 )
 
 const (

store/vouchers.go

@@ -15,6 +15,11 @@ var (
 	logg = logging.NewVanilla().WithDomain("vouchers").WithContextKey("SessionId")
 )
 
+// symbolReplacements holds mappings of invalid symbols → valid ones
+var symbolReplacements = map[string]string{
+	"USD₮": "USDT",
+}
+
 // VoucherMetadata helps organize data fields
 type VoucherMetadata struct {
 	Symbols   string
@@ -23,13 +28,24 @@ type VoucherMetadata struct {
 	Addresses string
 }
 
+// sanitizeSymbol replaces known invalid token symbols with normalized ones
+func sanitizeSymbol(symbol string) string {
+	if replacement, ok := symbolReplacements[symbol]; ok {
+		return replacement
+	}
+	return symbol
+}
+
 // ProcessVouchers converts holdings into formatted strings
 func ProcessVouchers(holdings []dataserviceapi.TokenHoldings) VoucherMetadata {
 	var data VoucherMetadata
 	var symbols, balances, decimals, addresses []string
 
 	for i, h := range holdings {
-		symbols = append(symbols, fmt.Sprintf("%d:%s", i+1, h.TokenSymbol))
+		// normalize token symbol before use
+		cleanSymbol := sanitizeSymbol(h.TokenSymbol)
+
+		symbols = append(symbols, fmt.Sprintf("%d:%s", i+1, cleanSymbol))
 
 		// Scale down the balance
 		scaledBalance := ScaleDownBalance(h.Balance, h.TokenDecimals)

store/vouchers_test.go

@@ -61,13 +61,14 @@ func TestProcessVouchers(t *testing.T) {
 	holdings := []dataserviceapi.TokenHoldings{
 		{TokenAddress: "0xd4c288865Ce", TokenSymbol: "SRF", TokenDecimals: "6", Balance: "100000000"},
 		{TokenAddress: "0x41c188d63Qa", TokenSymbol: "MILO", TokenDecimals: "4", Balance: "200000000"},
+		{TokenAddress: "0x41c143d63Qa", TokenSymbol: "USD₮", TokenDecimals: "6", Balance: "300000000"},
 	}
 
 	expectedResult := VoucherMetadata{
-		Symbols:   "1:SRF\n2:MILO",
+		Symbols:   "1:SRF\n2:MILO\n3:USDT",
-		Balances:  "1:100\n2:20000",
+		Balances:  "1:100\n2:20000\n3:300",
-		Decimals:  "1:6\n2:4",
+		Decimals:  "1:6\n2:4\n3:6",
-		Addresses: "1:0xd4c288865Ce\n2:0x41c188d63Qa",
+		Addresses: "1:0xd4c288865Ce\n2:0x41c188d63Qa\n3:0x41c143d63Qa",
 	}
 
 	result := ProcessVouchers(holdings)