.env.example

@@ -34,6 +34,10 @@ INCLUDE_STABLES_PARAM=false
 DEFAULT_MPESA_ADDRESS=0x48a953cA5cf5298bc6f6Af3C608351f537AAcb9e
 MIN_MPESA_SEND_AMOUNT=100
 MAX_MPESA_SEND_AMOUNT=250000
+MIN_MPESA_WITHDRAW_AMOUNT=20
 DEFAULT_MPESA_ASSET=cUSD
 MPESA_BEARER_TOKEN=eyJeSIsInRcCI6IkpXVCJ.yJwdWJsaWNLZXkiOiIwrrrrrr
 MPESA_ONRAMP_BASE=https://pretium.v1.grassecon.net
+
+# Known stable voucher addresses (USDT, USDm)
+STABLE_VOUCHER_ADDRESSES=0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e,0x765DE816845861e75A25fCA122bb6898B8B1282a

config/config.go

@@ -102,6 +102,16 @@ func MinMpesaSendAmount() float64 {
 	return f
 }
 
+func MinMpesaWithdrawAmount() float64 {
+	v := env.GetEnv("MIN_MPESA_WITHDRAW_AMOUNT", "20")
+	f, err := strconv.ParseFloat(v, 64)
+	if err != nil {
+		return 20 // fallback
+	}
+	return f
+}
+
+
 func MaxMpesaSendAmount() float64 {
 	v := env.GetEnv("MAX_MPESA_SEND_AMOUNT", "250000")
 	f, err := strconv.ParseFloat(v, 64)
@@ -114,3 +124,22 @@ func MaxMpesaSendAmount() float64 {
 func DefaultMpesaAsset() string {
 	return env.GetEnv("DEFAULT_MPESA_ASSET", "")
 }
+
+func StableVoucherAddresses() []string {
+	var parsed []string
+
+	raw := env.GetEnv("STABLE_VOUCHER_ADDRESSES", "")
+	if raw == "" {
+		return parsed
+	}
+
+	list := strings.Split(raw, ",")
+	for _, addr := range list {
+		clean := strings.ToLower(strings.TrimSpace(addr))
+		if clean != "" {
+			parsed = append(parsed, clean)
+		}
+	}
+
+	return parsed
+}

go.mod

@@ -7,7 +7,7 @@ toolchain go1.24.10
 require (
 	git.defalsify.org/vise.git v0.3.2-0.20250528124150-03bf7bfc1b66
 	git.grassecon.net/grassrootseconomics/common v0.9.0-beta.1.0.20251127132814-8ceadabbc215
-	git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20251202085112-45469d4ba326
+	git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20260207150752-71aa5ce7b537
 	git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2.0.20250408094335-e2d1f65bb306
 	git.grassecon.net/grassrootseconomics/visedriver-africastalking v0.0.0-20250129070628-5a539172c694
 	github.com/alecthomas/assert/v2 v2.2.2

go.sum

@@ -6,6 +6,8 @@ git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20251128071248-
 git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20251128071248-bfdeef125576/go.mod h1:h/y/lJNJAVTcIzAxCMXXw8Dh2aoLxBFZ6F1nTB8C0nU=
 git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20251202085112-45469d4ba326 h1:qH4QulgncvAD7b/YeHGPxcDJTBIychPeoZJACefYryI=
 git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20251202085112-45469d4ba326/go.mod h1:h/y/lJNJAVTcIzAxCMXXw8Dh2aoLxBFZ6F1nTB8C0nU=
+git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20260207150752-71aa5ce7b537 h1:2AoOHiRTN3SXX4qnc2wOaF2ktVXLlFAa3X/n9DLu8/s=
+git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20260207150752-71aa5ce7b537/go.mod h1:h/y/lJNJAVTcIzAxCMXXw8Dh2aoLxBFZ6F1nTB8C0nU=
 git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2.0.20250408094335-e2d1f65bb306 h1:Jo+yWysWw/N5BJQtAyEMN8ePVvAyPHv+JG4lQti+1N4=
 git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2.0.20250408094335-e2d1f65bb306/go.mod h1:FdLwYtzsjOIcDiW4uDgDYnB4Wdzq12uJUe0QHSSPbSo=
 git.grassecon.net/grassrootseconomics/visedriver-africastalking v0.0.0-20250129070628-5a539172c694 h1:DjJlBSz0S13acft5XZDWk7ZYnzElym0xLMYEVgyNJ+E=

handlers/application/balance.go

@@ -3,11 +3,16 @@ package application
 import (
 	"context"
 	"fmt"
+	"sort"
+	"strconv"
+	"strings"
 
 	"git.defalsify.org/vise.git/db"
 	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
 	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
+	dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
 	"gopkg.in/leonelquinteros/gotext.v1"
 )
 
@@ -52,6 +57,7 @@ func (h *MenuHandlers) CheckBalance(ctx context.Context, sym string, input []byt
 			return res, err
 		}
 	}
+
 	content, err = loadUserContent(ctx, string(activeSym), string(activeBal), string(accAlias))
 	if err != nil {
 		return res, err
@@ -62,7 +68,7 @@ func (h *MenuHandlers) CheckBalance(ctx context.Context, sym string, input []byt
 }
 
 // loadUserContent loads the main user content in the main menu: the alias, balance and active symbol associated with active voucher
-func loadUserContent(ctx context.Context, activeSym string, balance string, alias string) (string, error) {
+func loadUserContent(ctx context.Context, activeSym, balance, alias string) (string, error) {
 	var content string
 
 	code := codeFromCtx(ctx)
@@ -75,8 +81,9 @@ func loadUserContent(ctx context.Context, activeSym string, balance string, alia
 		formattedAmount = "0.00"
 	}
 
-	// format the final output
+	// format the final outputs
 	balStr := fmt.Sprintf("%s %s", formattedAmount, activeSym)
+
 	if alias != "" {
 		content = l.Get("%s\nBalance: %s\n", alias, balStr)
 	} else {
@@ -98,3 +105,141 @@ func (h *MenuHandlers) FetchCommunityBalance(ctx context.Context, sym string, in
 	res.Content = l.Get("Community Balance: 0.00")
 	return res, nil
 }
+
+// CalculateCreditAndDebt calls the API to get the credit and debt
+// uses the pretium rates to convert the value to Ksh
+func (h *MenuHandlers) CalculateCreditAndDebt(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")
+	}
+
+	userStore := h.userdataStore
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+
+	// default response
+	res.FlagReset = append(res.FlagReset, flag_api_call_error)
+	res.Content = l.Get("Credit: %s KSH\nDebt: %s KSH\n", "0", "0")
+
+	// Fetch session data
+	_, activeBal, activeSym, _, publicKey, _, err := h.getSessionData(ctx, sessionId)
+	if err != nil {
+		return res, nil
+	}
+
+	// Resolve active pool
+	activePoolAddress, _, err := h.resolveActivePoolDetails(ctx, sessionId)
+	if err != nil {
+		return res, err
+	}
+
+	// Fetch swappable vouchers
+	swappableVouchers, err := h.accountService.GetPoolSwappableFromVouchers(ctx, string(activePoolAddress), string(publicKey))
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on GetPoolSwappableFromVouchers", "error", err)
+		return res, nil
+	}
+
+	if len(swappableVouchers) == 0 {
+		return res, nil
+	}
+
+	// Build stable voucher priority (lower index = higher priority)
+	stablePriority := make(map[string]int)
+	stableAddresses := config.StableVoucherAddresses()
+	for i, addr := range stableAddresses {
+		stablePriority[strings.ToLower(addr)] = i
+	}
+
+	// Helper: order vouchers (stable first, priority-based)
+	orderVouchers := func(vouchers []dataserviceapi.TokenHoldings) []dataserviceapi.TokenHoldings {
+		stable := make([]dataserviceapi.TokenHoldings, 0)
+		nonStable := make([]dataserviceapi.TokenHoldings, 0)
+
+		for _, v := range vouchers {
+			if isStableVoucher(v.TokenAddress) {
+				stable = append(stable, v)
+			} else {
+				nonStable = append(nonStable, v)
+			}
+		}
+
+		sort.SliceStable(stable, func(i, j int) bool {
+			ai := stablePriority[strings.ToLower(stable[i].TokenAddress)]
+			aj := stablePriority[strings.ToLower(stable[j].TokenAddress)]
+			return ai < aj
+		})
+
+		return append(stable, nonStable...)
+	}
+
+	// Remove active voucher
+	filteredVouchers := make([]dataserviceapi.TokenHoldings, 0, len(swappableVouchers))
+	for _, v := range swappableVouchers {
+		if v.TokenSymbol != string(activeSym) {
+			filteredVouchers = append(filteredVouchers, v)
+		}
+	}
+
+	// Order remaining vouchers
+	orderedFilteredVouchers := orderVouchers(filteredVouchers)
+
+	// Process & store
+	data := store.ProcessVouchers(orderedFilteredVouchers)
+
+	dataMap := map[storedb.DataTyp]string{
+		storedb.DATA_VOUCHER_SYMBOLS:   data.Symbols,
+		storedb.DATA_VOUCHER_BALANCES:  data.Balances,
+		storedb.DATA_VOUCHER_DECIMALS:  data.Decimals,
+		storedb.DATA_VOUCHER_ADDRESSES: data.Addresses,
+	}
+
+	for key, value := range dataMap {
+		if err := userStore.WriteEntry(ctx, sessionId, key, []byte(value)); err != nil {
+			logg.ErrorCtxf(ctx, "Failed to write data entry for sessionId: %s", sessionId, "key", key, "error", err)
+			continue
+		}
+	}
+
+	// Credit = active voucher balance
+	scaledCredit := string(activeBal)
+
+	// Debt = sum of stable vouchers only
+	scaledDebt := "0"
+	for _, v := range orderedFilteredVouchers {
+		scaled := store.ScaleDownBalance(v.Balance, v.TokenDecimals)
+		scaledDebt = store.AddDecimalStrings(scaledDebt, scaled)
+	}
+
+	// Fetch MPESA rates
+	rates, err := h.accountService.GetMpesaOnrampRates(ctx)
+	if err != nil {
+		res.FlagSet = append(res.FlagSet, flag_api_call_error)
+		res.Content = l.Get("Your request failed. Please try again later.")
+		logg.ErrorCtxf(ctx, "failed on GetMpesaOnrampRates", "error", err)
+		return res, nil
+	}
+
+	creditFloat, _ := strconv.ParseFloat(scaledCredit, 64)
+	debtFloat, _ := strconv.ParseFloat(scaledDebt, 64)
+
+	creditKsh := fmt.Sprintf("%f", creditFloat*rates.Buy)
+	debtKsh := fmt.Sprintf("%f", debtFloat*rates.Buy)
+
+	kshFormattedCredit, _ := store.TruncateDecimalString(creditKsh, 0)
+	kshFormattedDebt, _ := store.TruncateDecimalString(debtKsh, 0)
+
+	res.Content = l.Get(
+		"Credit: %s KSH\nDebt: %s KSH\n",
+		kshFormattedCredit,
+		kshFormattedDebt,
+	)
+
+	return res, nil
+}

handlers/application/mpesa.go

@@ -28,20 +28,36 @@ func (h *MenuHandlers) GetMpesaMaxLimit(ctx context.Context, sym string, input [
 	flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
 	flag_low_swap_amount, _ := h.flagManager.GetFlag("flag_low_swap_amount")
 	flag_incorrect_pool, _ := h.flagManager.GetFlag("flag_incorrect_pool")
+	flag_incorrect_voucher, _ := h.flagManager.GetFlag("flag_incorrect_voucher")
 
 	code := codeFromCtx(ctx)
 	l := gotext.NewLocale(translationDir, code)
 	l.AddDomain("default")
 
 	inputStr := string(input)
-	if inputStr == "0" || inputStr == "9" {
+	if inputStr == "0" || inputStr == "99" || inputStr == "88" || inputStr == "98" {
+		res.FlagReset = append(res.FlagReset, flag_low_swap_amount, flag_api_call_error, flag_incorrect_voucher)
 		return res, nil
 	}
 
 	userStore := h.userdataStore
+	metadata, err := store.GetOrderedVoucherData(ctx, userStore, sessionId, inputStr)
+	if err != nil {
+		return res, fmt.Errorf("failed to retrieve swap to voucher data: %v", err)
+	}
+	if metadata == nil {
+		res.FlagSet = append(res.FlagSet, flag_incorrect_voucher)
+		return res, nil
+	}
+
+	// Store the active transaction voucher data
+	if err := store.StoreTemporaryVoucher(ctx, h.userdataStore, sessionId, metadata); err != nil {
+		logg.ErrorCtxf(ctx, "failed on StoreTemporaryVoucher", "error", err)
+		return res, err
+	}
 
 	// Fetch session data
-	_, activeBal, _, activeAddress, publicKey, activeDecimal, err := h.getSessionData(ctx, sessionId)
+	_, _, _, _, publicKey, _, err := h.getSessionData(ctx, sessionId)
 	if err != nil {
 		return res, err
 	}
@@ -83,8 +99,12 @@ func (h *MenuHandlers) GetMpesaMaxLimit(ctx context.Context, sym string, input [
 		return res, err
 	}
 
+	// Fetch min withdrawal amount from config/env
+	minksh := fmt.Sprintf("%f", config.MinMpesaWithdrawAmount())
+	minKshFormatted, _ := store.TruncateDecimalString(minksh, 0)
+
 	// If RAT is the same as SAT, return early with KSH format
-	if string(activeAddress) == string(recipientActiveAddress) {
+	if string(metadata.TokenAddress) == string(recipientActiveAddress) {
 		txType = "normal"
 		// Save the transaction type
 		if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_SEND_TRANSACTION_TYPE, []byte(txType)); err != nil {
@@ -92,27 +112,28 @@ func (h *MenuHandlers) GetMpesaMaxLimit(ctx context.Context, sym string, input [
 			return res, err
 		}
 
-		activeFloat, _ := strconv.ParseFloat(string(activeBal), 64)
+		activeFloat, _ := strconv.ParseFloat(string(metadata.Balance), 64)
 		ksh := fmt.Sprintf("%f", activeFloat*rates.Buy)
 
-		kshFormatted, _ := store.TruncateDecimalString(ksh, 0)
+		maxKshFormatted, _ := store.TruncateDecimalString(ksh, 0)
 
 		res.Content = l.Get(
-			"Enter the amount of Mpesa to get: (Max %s Ksh)\n",
-			kshFormatted,
+			"Enter the amount of Mpesa to withdraw: (Min: Ksh %s, Max %s Ksh)\n",
+			minKshFormatted,
+			maxKshFormatted,
 		)
 
 		return res, nil
 	}
 
 	// Resolve active pool address
-	activePoolAddress, err := h.resolveActivePoolAddress(ctx, sessionId)
+	activePoolAddress, _, err := h.resolveActivePoolDetails(ctx, sessionId)
 	if err != nil {
 		return res, err
 	}
 
 	// Check if sender token is swappable
-	canSwap, err := h.accountService.CheckTokenInPool(ctx, string(activePoolAddress), string(activeAddress))
+	canSwap, err := h.accountService.CheckTokenInPool(ctx, string(activePoolAddress), string(metadata.TokenAddress))
 	if err != nil {
 		res.FlagSet = append(res.FlagSet, flag_api_call_error)
 		logg.ErrorCtxf(ctx, "failed on CheckTokenInPool", "error", err)
@@ -125,7 +146,7 @@ func (h *MenuHandlers) GetMpesaMaxLimit(ctx context.Context, sym string, input [
 	}
 
 	// retrieve the max credit send amounts
-	_, maxRAT, err := h.calculateSendCreditLimits(ctx, activePoolAddress, activeAddress, recipientActiveAddress, publicKey, activeDecimal, recipientActiveDecimal)
+	_, maxRAT, err := h.calculateSendCreditLimits(ctx, activePoolAddress, []byte(metadata.TokenAddress), recipientActiveAddress, publicKey, []byte(metadata.TokenDecimals), recipientActiveDecimal)
 	if err != nil {
 		res.FlagSet = append(res.FlagSet, flag_api_call_error)
 		logg.ErrorCtxf(ctx, "failed on calculateSendCreditLimits", "error", err)
@@ -155,25 +176,26 @@ func (h *MenuHandlers) GetMpesaMaxLimit(ctx context.Context, sym string, input [
 	}
 
 	// save swap related data for the swap preview
-	metadata := &dataserviceapi.TokenHoldings{
+	swapMetadata := &dataserviceapi.TokenHoldings{
 		TokenAddress:  string(recipientActiveAddress),
 		TokenSymbol:   string(recipientActiveSym),
 		TokenDecimals: string(recipientActiveDecimal),
 	}
 
 	// Store the active swap_to data
-	if err := store.UpdateSwapToVoucherData(ctx, userStore, sessionId, metadata); err != nil {
+	if err := store.UpdateSwapToVoucherData(ctx, userStore, sessionId, swapMetadata); err != nil {
 		logg.ErrorCtxf(ctx, "failed on UpdateSwapToVoucherData", "error", err)
 		return res, err
 	}
 
 	maxKsh := maxFloat * rates.Buy
 	kshStr := fmt.Sprintf("%f", maxKsh)
-	kshFormatted, _ := store.TruncateDecimalString(kshStr, 0)
+	maxKshFormatted, _ := store.TruncateDecimalString(kshStr, 0)
 
 	res.Content = l.Get(
-		"Enter the amount of Mpesa to get: (Max %s Ksh)\n",
-		kshFormatted,
+		"Enter the amount of Mpesa to withdraw: (Min: Ksh %s, Max %s Ksh)\n",
+		minKshFormatted,
+		maxKshFormatted,
 	)
 
 	return res, nil
@@ -189,7 +211,7 @@ func (h *MenuHandlers) GetMpesaPreview(ctx context.Context, sym string, input []
 
 	// INPUT IN RAT Ksh
 	inputStr := string(input)
-	if inputStr == "9" {
+	if inputStr == "0" || inputStr == "9" {
 		return res, nil
 	}
 
@@ -219,16 +241,18 @@ func (h *MenuHandlers) GetMpesaPreview(ctx context.Context, sym string, input []
 		return res, nil
 	}
 
+	min := config.MinMpesaWithdrawAmount()
+
+	if kshAmount < min {
+		// if the input is below the minimum
+		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+		res.Content = inputStr
+		return res, nil
+	}
+
 	// divide by the buy rate
 	inputAmount := kshAmount / rates.Buy
 
-	// store the user's raw 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 temporary inputStr entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", inputStr, "error", err)
-		return res, err
-	}
-
 	swapData, err := store.ReadSwapPreviewData(ctx, userStore, sessionId)
 	if err != nil {
 		return res, err
@@ -239,19 +263,21 @@ func (h *MenuHandlers) GetMpesaPreview(ctx context.Context, sym string, input []
 		return res, err
 	}
 
-	if string(transactionType) == "normal" {
-		activeBal, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
+	// get the selected voucher
+	mpesaWithdrawalVoucher, err := store.GetTemporaryVoucherData(ctx, h.userdataStore, sessionId)
 	if err != nil {
-			logg.ErrorCtxf(ctx, "failed to read activeBal entry with", "key", storedb.DATA_ACTIVE_BAL, "error", err)
-			return res, err
-		}
-		balanceValue, err := strconv.ParseFloat(string(activeBal), 64)
-		if err != nil {
-			logg.ErrorCtxf(ctx, "Failed to convert the activeBal to a float", "error", err)
+		logg.ErrorCtxf(ctx, "failed on GetTemporaryVoucherData", "error", err)
 		return res, err
 	}
 
-		if inputAmount > balanceValue {
+	maxValue, err := strconv.ParseFloat(mpesaWithdrawalVoucher.Balance, 64)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "Failed to convert the swapMaxAmount to a float", "error", err)
+		return res, err
+	}
+
+	if string(transactionType) == "normal" {
+		if inputAmount > maxValue {
 			res.FlagSet = append(res.FlagSet, flag_invalid_amount)
 			res.Content = inputStr
 			return res, nil
@@ -270,7 +296,7 @@ func (h *MenuHandlers) GetMpesaPreview(ctx context.Context, sym string, input []
 
 		res.Content = l.Get(
 			"You are sending %s %s in order to receive ~ %s ksh",
-			qouteInputAmount, swapData.ActiveSwapFromSym, inputStr,
+			qouteInputAmount, mpesaWithdrawalVoucher.TokenSymbol, inputStr,
 		)
 
 		return res, nil
@@ -365,6 +391,12 @@ func (h *MenuHandlers) InitiateGetMpesa(ctx context.Context, sym string, input [
 		return res, err
 	}
 
+	mpesaWithdrawalVoucher, err := store.GetTemporaryVoucherData(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on GetTemporaryVoucherData", "error", err)
+		return res, err
+	}
+
 	if string(transactionType) == "normal" {
 		// Call TokenTransfer for the normal transaction
 		data, err := store.ReadTransactionData(ctx, h.userdataStore, sessionId)
@@ -372,12 +404,12 @@ func (h *MenuHandlers) InitiateGetMpesa(ctx context.Context, sym string, input [
 			return res, err
 		}
 
-		finalAmountStr, err := store.ParseAndScaleAmount(data.Amount, data.ActiveDecimal)
+		finalAmountStr, err := store.ParseAndScaleAmount(data.Amount, mpesaWithdrawalVoucher.TokenDecimals)
 		if err != nil {
 			return res, err
 		}
 
-		tokenTransfer, err := h.accountService.TokenTransfer(ctx, finalAmountStr, data.PublicKey, mpesaAddress, data.ActiveAddress)
+		tokenTransfer, err := h.accountService.TokenTransfer(ctx, finalAmountStr, data.PublicKey, mpesaAddress, mpesaWithdrawalVoucher.TokenAddress)
 		if err != nil {
 			res.FlagSet = append(res.FlagSet, flag_api_call_error)
 			res.Content = l.Get("Your request failed. Please try again later.")
@@ -387,11 +419,10 @@ func (h *MenuHandlers) InitiateGetMpesa(ctx context.Context, sym string, input [
 
 		logg.InfoCtxf(ctx, "TokenTransfer normal", "trackingId", tokenTransfer.TrackingId)
 
-		res.Content = l.Get("Your request has been sent. You will receive ~ %s ksh", data.TemporaryValue)
+		res.Content = l.Get("Your request has been sent. Please await confirmation")
 
 		res.FlagReset = append(res.FlagReset, flag_account_authorized)
 		return res, nil
-
 	}
 
 	swapAmount, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SWAP_AMOUNT)
@@ -417,11 +448,6 @@ func (h *MenuHandlers) InitiateGetMpesa(ctx context.Context, sym string, input [
 	// TODO: remove this temporary time delay and replace with a swap and send endpoint
 	time.Sleep(1 * time.Second)
 
-	finalKshStr, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
-	if err != nil {
-		return res, err
-	}
-
 	amount, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_AMOUNT)
 	if err != nil {
 		return res, err
@@ -438,7 +464,7 @@ func (h *MenuHandlers) InitiateGetMpesa(ctx context.Context, sym string, input [
 
 	logg.InfoCtxf(ctx, "final TokenTransfer after swap", "trackingId", tokenTransfer.TrackingId)
 
-	res.Content = l.Get("Your request has been sent. You will receive ~ %s ksh", finalKshStr)
+	res.Content = l.Get("Your request has been sent. Please await confirmation")
 	res.FlagReset = append(res.FlagReset, flag_account_authorized)
 	return res, nil
 }

handlers/application/paydebt.go

@@ -0,0 +1,320 @@
+package application
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
+	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
+	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
+	"gopkg.in/leonelquinteros/gotext.v1"
+)
+
+// CalculateMaxPayDebt calculates the max debt removal based on the selected voucher
+func (h *MenuHandlers) CalculateMaxPayDebt(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")
+	}
+
+	flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+	flag_low_swap_amount, _ := h.flagManager.GetFlag("flag_low_swap_amount")
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	inputStr := string(input)
+	if inputStr == "0" || inputStr == "99" || inputStr == "88" || inputStr == "98" {
+		res.FlagReset = append(res.FlagReset, flag_low_swap_amount, flag_api_call_error)
+		return res, nil
+	}
+
+	userStore := h.userdataStore
+
+	// Fetch session data
+	_, _, activeSym, activeAddress, publicKey, activeDecimal, err := h.getSessionData(ctx, sessionId)
+	if err != nil {
+		return res, nil
+	}
+
+	// Resolve active pool
+	activePoolAddress, activePoolName, err := h.resolveActivePoolDetails(ctx, sessionId)
+	if err != nil {
+		res.FlagReset = append(res.FlagReset, flag_low_swap_amount, flag_api_call_error)
+		return res, err
+	}
+
+	// get the voucher data based on the input
+	metadata, err := store.GetVoucherData(ctx, userStore, sessionId, inputStr)
+	if err != nil {
+		res.FlagReset = append(res.FlagReset, flag_low_swap_amount, flag_api_call_error)
+		return res, fmt.Errorf("failed to retrieve swap to voucher data: %v", err)
+	}
+	if metadata == nil {
+		res.FlagSet = append(res.FlagSet, flag_api_call_error)
+		return res, nil
+	}
+
+	// Get the max swap limit with the selected voucher
+	r, err := h.accountService.GetSwapFromTokenMaxLimit(ctx, string(activePoolAddress), metadata.TokenAddress, string(activeAddress), string(publicKey))
+	if err != nil {
+		res.FlagSet = append(res.FlagSet, flag_api_call_error)
+		logg.ErrorCtxf(ctx, "failed on GetSwapFromTokenMaxLimit", "error", err)
+		return res, nil
+	}
+
+	maxLimit := r.Max
+
+	metadata.Balance = maxLimit
+
+	// Store the active swap from data
+	if err := store.UpdateSwapFromVoucherData(ctx, userStore, sessionId, metadata); err != nil {
+		logg.ErrorCtxf(ctx, "failed on UpdateSwapFromVoucherData", "error", err)
+		return res, err
+	}
+
+	// Scale down the amount
+	maxAmountStr := store.ScaleDownBalance(maxLimit, metadata.TokenDecimals)
+	if err != nil {
+		return res, err
+	}
+
+	maxAmountFloat, err := strconv.ParseFloat(maxAmountStr, 64)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to parse maxAmountStr as float", "value", maxAmountStr, "error", err)
+		return res, err
+	}
+
+	// Format to 2 decimal places
+	maxStr, _ := store.TruncateDecimalString(string(maxAmountStr), 2)
+
+	if maxAmountFloat < 0.1 {
+		// return with low amount flag
+		res.Content = maxStr
+		res.FlagSet = append(res.FlagSet, flag_low_swap_amount)
+		return res, nil
+	}
+
+	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 entry with", "key", storedb.DATA_ACTIVE_SWAP_MAX_AMOUNT, "value", maxStr, "error", err)
+		return res, err
+	}
+
+	// Do a pool quote to get the max AT that can be removed (gotten)
+	// if we swapped the max of the FT
+
+	// call the API to get the quote
+	qoute, err := h.accountService.GetPoolSwapQuote(ctx, maxLimit, string(publicKey), metadata.TokenAddress, string(activePoolAddress), string(activeAddress))
+	if err != nil {
+		flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+		res.FlagSet = append(res.FlagSet, flag_api_call_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(qoute.OutValue, string(activeDecimal))
+
+	// Format to 2 decimal places
+	quoteStr, _ := store.TruncateDecimalString(string(quoteAmountStr), 2)
+
+	res.Content = l.Get(
+		"You can remove a max of %s %s from '%s'\nEnter amount of %s:(Max: %s)",
+		quoteStr,
+		string(activeSym),
+		string(activePoolName),
+		metadata.TokenSymbol,
+		maxStr,
+	)
+
+	res.FlagReset = append(res.FlagReset, flag_low_swap_amount, flag_api_call_error)
+
+	return res, nil
+}
+
+// ConfirmDebtRemoval displays the debt preview for a confirmation
+func (h *MenuHandlers) ConfirmDebtRemoval(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
+
+	// Fetch session data
+	_, _, activeSym, activeAddress, publicKey, _, err := h.getSessionData(ctx, sessionId)
+	if err != nil {
+		return res, nil
+	}
+
+	payDebtVoucher, err := store.ReadSwapFromVoucher(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on ReadSwapFromVoucher", "error", err)
+		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 || inputAmount < 0.1 {
+		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+		res.Content = inputStr
+		return res, nil
+	}
+
+	var finalAmountStr string
+	if inputStr == swapData.ActiveSwapMaxAmount {
+		finalAmountStr = string(payDebtVoucher.Balance)
+	} else {
+		finalAmountStr, err = store.ParseAndScaleAmount(inputStr, payDebtVoucher.TokenDecimals)
+		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
+	}
+
+	// call the API to get the quote
+	r, err := h.accountService.GetPoolSwapQuote(ctx, finalAmountStr, string(publicKey), payDebtVoucher.TokenAddress, swapData.ActivePoolAddress, string(activeAddress))
+	if err != nil {
+		flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+		res.FlagSet = append(res.FlagSet, flag_api_call_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.ActiveSwapFromDecimal)
+
+	// Format to 2 decimal places
+	qouteStr, _ := store.TruncateDecimalString(string(quoteAmountStr), 2)
+
+	// store the quote in the temporary value key
+	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(qouteStr))
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to write swap max amount entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", qouteStr, "error", err)
+		return res, err
+	}
+
+	res.Content = l.Get(
+		"Please confirm that you will use %s %s to remove your debt of %s %s\n",
+		inputStr, payDebtVoucher.TokenSymbol, qouteStr, string(activeSym),
+	)
+
+	return res, nil
+}
+
+// InitiatePayDebt calls the poolSwap to swap the token for the active voucher.
+func (h *MenuHandlers) InitiatePayDebt(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")
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	userStore := h.userdataStore
+
+	// Fetch session data
+	_, _, activeSym, activeAddress, publicKey, _, err := h.getSessionData(ctx, sessionId)
+	if err != nil {
+		return res, nil
+	}
+
+	// Resolve active pool
+	activePoolAddress, activePoolName, err := h.resolveActivePoolDetails(ctx, sessionId)
+	if err != nil {
+		return res, err
+	}
+
+	payDebtVoucher, err := store.ReadSwapFromVoucher(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on ReadSwapFromVoucher", "error", err)
+		return res, err
+	}
+
+	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
+	r, err := h.accountService.PoolSwap(ctx, swapAmountStr, string(publicKey), payDebtVoucher.TokenAddress, string(activePoolAddress), string(activeAddress))
+	if err != nil {
+		flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+		res.FlagSet = append(res.FlagSet, flag_api_call_error)
+		res.Content = l.Get("Your request failed. Please try again later.")
+		logg.ErrorCtxf(ctx, "failed on poolSwap", "error", err)
+		return res, nil
+	}
+
+	trackingId := r.TrackingId
+	logg.InfoCtxf(ctx, "poolSwap", "trackingId", trackingId)
+
+	res.Content = l.Get(
+		"Your request has been sent. You will receive an SMS when your debt of %s %s has been removed from %s.",
+		swapData.TemporaryValue,
+		string(activeSym),
+		activePoolName,
+	)
+
+	res.FlagReset = append(res.FlagReset, flag_account_authorized)
+	return res, nil
+}
+
+func isStableVoucher(tokenAddress string) bool {
+	addr := strings.ToLower(strings.TrimSpace(tokenAddress))
+	for _, stable := range config.StableVoucherAddresses() {
+		if addr == stable {
+			return true
+		}
+	}
+	return false
+}

handlers/application/pool_deposit.go

@@ -0,0 +1,220 @@
+package application
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
+	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
+	"gopkg.in/leonelquinteros/gotext.v1"
+)
+
+// GetOrderedVouchers returns a list of ordered vouchers with stables at the top
+func (h *MenuHandlers) GetOrderedVouchers(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")
+	}
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	userStore := h.userdataStore
+
+	// Read ordered vouchers from the store
+	voucherData, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ORDERED_VOUCHER_SYMBOLS)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read stable voucherData entires with", "key", storedb.DATA_ORDERED_VOUCHER_SYMBOLS, "error", err)
+		return res, err
+	}
+
+	if len(voucherData) == 0 {
+		return res, nil
+	}
+
+	voucherBalances, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ORDERED_VOUCHER_BALANCES)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read stable voucherData entires with", "key", storedb.DATA_ORDERED_VOUCHER_BALANCES, "error", err)
+		return res, err
+	}
+
+	formattedVoucherList := store.FormatVoucherList(ctx, string(voucherData), string(voucherBalances))
+	finalOutput := strings.Join(formattedVoucherList, "\n")
+
+	res.Content = l.Get("Select number or symbol from your vouchers:\n%s", finalOutput)
+
+	return res, nil
+}
+
+// PoolDepositMaxAmount returns the balance of the selected voucher
+func (h *MenuHandlers) PoolDepositMaxAmount(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")
+	}
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	flag_incorrect_voucher, _ := h.flagManager.GetFlag("flag_incorrect_voucher")
+
+	res.FlagReset = append(res.FlagReset, flag_incorrect_voucher)
+
+	inputStr := string(input)
+	if inputStr == "0" || inputStr == "99" || inputStr == "88" || inputStr == "98" {
+		return res, nil
+	}
+
+	userStore := h.userdataStore
+	metadata, err := store.GetOrderedVoucherData(ctx, userStore, sessionId, inputStr)
+	if err != nil {
+		return res, fmt.Errorf("failed to retrieve swap to voucher data: %v", err)
+	}
+	if metadata == nil {
+		res.FlagSet = append(res.FlagSet, flag_incorrect_voucher)
+		return res, nil
+	}
+
+	// Store the pool deposit voucher data
+	if err := store.StoreTemporaryVoucher(ctx, h.userdataStore, sessionId, metadata); err != nil {
+		logg.ErrorCtxf(ctx, "failed on StoreTemporaryVoucher", "error", err)
+		return res, err
+	}
+
+	// Format the balance amount to 2 decimal places
+	formattedBalance, _ := store.TruncateDecimalString(string(metadata.Balance), 2)
+
+	res.Content = l.Get("Maximum amount: %s %s\nEnter amount:", formattedBalance, metadata.TokenSymbol)
+
+	return res, nil
+}
+
+// ConfirmPoolDeposit displays the pool deposit preview for a PIN confirmation
+func (h *MenuHandlers) ConfirmPoolDeposit(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")
+
+	res.FlagReset = append(res.FlagReset, flag_invalid_amount)
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	userStore := h.userdataStore
+
+	poolDepositVoucher, err := store.GetTemporaryVoucherData(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on GetTemporaryVoucherData", "error", err)
+		return res, err
+	}
+
+	maxValue, err := strconv.ParseFloat(poolDepositVoucher.Balance, 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 || inputAmount < 0.1 {
+		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
+		res.Content = inputStr
+		return res, nil
+	}
+
+	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_AMOUNT, []byte(inputStr))
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to write pool deposit amount entry with", "key", storedb.DATA_AMOUNT, "value", inputStr, "error", err)
+		return res, err
+	}
+
+	// Resolve active pool
+	_, activePoolName, err := h.resolveActivePoolDetails(ctx, sessionId)
+	if err != nil {
+		return res, err
+	}
+
+	res.Content = l.Get(
+		"You will deposit %s %s into %s\n",
+		inputStr, poolDepositVoucher.TokenSymbol, activePoolName,
+	)
+
+	return res, nil
+}
+
+// InitiatePoolDeposit calls the pool deposit API
+func (h *MenuHandlers) InitiatePoolDeposit(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")
+
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
+	// Resolve active pool
+	activePoolAddress, activePoolName, err := h.resolveActivePoolDetails(ctx, sessionId)
+	if err != nil {
+		return res, err
+	}
+
+	poolDepositVoucher, err := store.GetTemporaryVoucherData(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed on GetTemporaryVoucherData", "error", err)
+		return res, err
+	}
+
+	poolDepositdata, err := store.ReadTransactionData(ctx, h.userdataStore, sessionId)
+	if err != nil {
+		return res, err
+	}
+
+	finalAmountStr, err := store.ParseAndScaleAmount(poolDepositdata.Amount, poolDepositVoucher.TokenDecimals)
+	if err != nil {
+		return res, err
+	}
+
+	// Call pool deposit API
+	r, err := h.accountService.PoolDeposit(ctx, finalAmountStr, poolDepositdata.PublicKey, string(activePoolAddress), poolDepositVoucher.TokenAddress)
+	if err != nil {
+		flag_api_call_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+		res.FlagSet = append(res.FlagSet, flag_api_call_error)
+		res.Content = l.Get("Your request failed. Please try again later.")
+		logg.ErrorCtxf(ctx, "failed on pool deposit", "error", err)
+		return res, nil
+	}
+
+	trackingId := r.TrackingId
+	logg.InfoCtxf(ctx, "Pool deposit", "trackingId", trackingId)
+
+	res.Content = l.Get(
+		"Your request has been sent. You will receive an SMS when %s %s has been deposited into %s.",
+		poolDepositdata.Amount,
+		poolDepositVoucher.TokenSymbol,
+		activePoolName,
+	)
+
+	res.FlagReset = append(res.FlagReset, flag_account_authorized)
+	return res, nil
+}

handlers/application/poolswap.go

@@ -303,7 +303,7 @@ func (h *MenuHandlers) SwapPreview(ctx context.Context, sym string, input []byte
 	// 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)
+		logg.ErrorCtxf(ctx, "failed to write inputStr amount entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", inputStr, "error", err)
 		return res, err
 	}
 

handlers/application/send.go

@@ -345,7 +345,7 @@ func (h *MenuHandlers) MaxAmount(ctx context.Context, sym string, input []byte)
 	}
 
 	// Resolve active pool address
-	activePoolAddress, err := h.resolveActivePoolAddress(ctx, sessionId)
+	activePoolAddress, _, err := h.resolveActivePoolDetails(ctx, sessionId)
 	if err != nil {
 		return res, err
 	}
@@ -479,22 +479,53 @@ func (h *MenuHandlers) getRecipientData(ctx context.Context, sessionId string) (
 	return
 }
 
-func (h *MenuHandlers) resolveActivePoolAddress(ctx context.Context, sessionId string) ([]byte, error) {
+func (h *MenuHandlers) resolveActivePoolDetails(ctx context.Context, sessionId string) (defaultPoolAddress, defaultPoolName []byte, err 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
-	}
+
+	// Try read address
+	defaultPoolAddress, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_POOL_ADDRESS)
+	if err != nil && !db.IsNotFound(err) {
 		logg.ErrorCtxf(ctx, "failed to read active pool address", "error", err)
-	return nil, err
+		return nil, nil, err
+	}
+
+	// Try read name
+	defaultPoolName, err = store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_POOL_NAME)
+	if err != nil && !db.IsNotFound(err) {
+		logg.ErrorCtxf(ctx, "failed to read active pool name", "error", err)
+		return nil, nil, err
+	}
+
+	// If both exist, return them
+	if defaultPoolAddress != nil && defaultPoolName != nil {
+		return defaultPoolAddress, defaultPoolName, nil
+	}
+
+	// Fallback to config defaults
+	defaultPoolAddress = []byte(config.DefaultPoolAddress())
+	defaultPoolName = []byte(config.DefaultPoolName())
+
+	if err := store.WriteEntry(
+		ctx,
+		sessionId,
+		storedb.DATA_ACTIVE_POOL_ADDRESS,
+		defaultPoolAddress,
+	); err != nil {
+		logg.ErrorCtxf(ctx, "failed to write default pool address", "error", err)
+		return nil, nil, err
+	}
+
+	if err := store.WriteEntry(
+		ctx,
+		sessionId,
+		storedb.DATA_ACTIVE_POOL_NAME,
+		defaultPoolName,
+	); err != nil {
+		logg.ErrorCtxf(ctx, "failed to write default pool name", "error", err)
+		return nil, nil, err
+	}
+
+	return defaultPoolAddress, defaultPoolName, nil
 }
 
 func (h *MenuHandlers) calculateSendCreditLimits(ctx context.Context, poolAddress, fromAddress, toAddress, publicKey, fromDecimal, toDecimal []byte) (string, string, error) {
@@ -554,7 +585,7 @@ func (h *MenuHandlers) ValidateAmount(ctx context.Context, sym string, input []b
 		return res, nil
 	}
 
-	if inputAmount > balanceValue {
+	if inputAmount > balanceValue || inputAmount < 0.1{
 		res.FlagSet = append(res.FlagSet, flag_invalid_amount)
 		res.Content = amountStr
 		return res, nil

handlers/application/vouchers.go

@@ -3,10 +3,12 @@ package application
 import (
 	"context"
 	"fmt"
+	"sort"
 	"strings"
 
 	"git.defalsify.org/vise.git/db"
 	"git.defalsify.org/vise.git/resource"
+	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
 	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
 	dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
@@ -16,7 +18,8 @@ import (
 // ManageVouchers retrieves the token holdings from the API using the "PublicKey" and
 // 1. sets the first as the default voucher if no active voucher is set.
 // 2. Stores list of vouchers
-// 3. updates the balance of the active voucher
+// 3. Stores list of filtered stable vouchers
+// 4. updates the balance of the active voucher
 func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	userStore := h.userdataStore
@@ -29,6 +32,7 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 
 	flag_no_active_voucher, _ := h.flagManager.GetFlag("flag_no_active_voucher")
 	flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")
+	flag_no_stable_vouchers, _ := h.flagManager.GetFlag("flag_no_stable_vouchers")
 
 	publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
 	if err != nil {
@@ -144,7 +148,36 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 		}
 	}
 
-	// Filter out the active voucher from vouchersResp
+	// Build stable voucher priority (lower index = higher priority)
+	stablePriority := make(map[string]int)
+	stableAddresses := config.StableVoucherAddresses()
+	for i, addr := range stableAddresses {
+		stablePriority[strings.ToLower(addr)] = i
+	}
+
+	// Helper: order vouchers (stable first, priority-based)
+	orderVouchers := func(vouchers []dataserviceapi.TokenHoldings) []dataserviceapi.TokenHoldings {
+		stable := make([]dataserviceapi.TokenHoldings, 0)
+		nonStable := make([]dataserviceapi.TokenHoldings, 0)
+
+		for _, v := range vouchers {
+			if isStableVoucher(v.TokenAddress) {
+				stable = append(stable, v)
+			} else {
+				nonStable = append(nonStable, v)
+			}
+		}
+
+		sort.SliceStable(stable, func(i, j int) bool {
+			ai := stablePriority[strings.ToLower(stable[i].TokenAddress)]
+			aj := stablePriority[strings.ToLower(stable[j].TokenAddress)]
+			return ai < aj
+		})
+
+		return append(stable, nonStable...)
+	}
+
+	// Remove active voucher
 	filteredVouchers := make([]dataserviceapi.TokenHoldings, 0, len(vouchersResp))
 	for _, v := range vouchersResp {
 		if v.TokenSymbol != activeSymStr {
@@ -152,8 +185,11 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 		}
 	}
 
-	// Store all voucher data (excluding the current active voucher)
-	data := store.ProcessVouchers(filteredVouchers)
+	// Order remaining vouchers
+	orderedFilteredVouchers := orderVouchers(filteredVouchers)
+
+	// Process & store
+	data := store.ProcessVouchers(orderedFilteredVouchers)
 
 	dataMap := map[storedb.DataTyp]string{
 		storedb.DATA_VOUCHER_SYMBOLS:   data.Symbols,
@@ -164,6 +200,41 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 
 	// Write data entries
 	for key, value := range dataMap {
+		if err := userStore.WriteEntry(ctx, sessionId, key, []byte(value)); err != nil {
+			logg.ErrorCtxf(ctx, "Failed to write data entry for sessionId: %s", sessionId, "key", key, "error", err)
+		}
+	}
+
+	// Order all vouchers
+	orderedVouchers := orderVouchers(vouchersResp)
+
+	// Stable voucher presence flag (based on full list)
+	hasStable := false
+	for _, v := range orderedVouchers {
+		if isStableVoucher(v.TokenAddress) {
+			hasStable = true
+			break
+		}
+	}
+
+	if !hasStable {
+		res.FlagSet = append(res.FlagSet, flag_no_stable_vouchers)
+	} else {
+		res.FlagReset = append(res.FlagReset, flag_no_stable_vouchers)
+	}
+
+	// Process ALL vouchers (stable first)
+	orderedVoucherData := store.ProcessVouchers(orderedVouchers)
+
+	orderedVoucherDataMap := map[storedb.DataTyp]string{
+		storedb.DATA_ORDERED_VOUCHER_SYMBOLS:   orderedVoucherData.Symbols,
+		storedb.DATA_ORDERED_VOUCHER_BALANCES:  orderedVoucherData.Balances,
+		storedb.DATA_ORDERED_VOUCHER_DECIMALS:  orderedVoucherData.Decimals,
+		storedb.DATA_ORDERED_VOUCHER_ADDRESSES: orderedVoucherData.Addresses,
+	}
+
+	// Write data entries
+	for key, value := range orderedVoucherDataMap {
 		if err := userStore.WriteEntry(ctx, sessionId, key, []byte(value)); err != nil {
 			logg.ErrorCtxf(ctx, "Failed to write data entry for sessionId: %s", sessionId, "key", key, "error", err)
 			continue
@@ -181,8 +252,18 @@ func (h *MenuHandlers) GetVoucherList(ctx context.Context, sym string, input []b
 		return res, fmt.Errorf("missing session")
 	}
 
+	code := codeFromCtx(ctx)
+	l := gotext.NewLocale(translationDir, code)
+	l.AddDomain("default")
+
 	userStore := h.userdataStore
 
+	// Fetch session data
+	_, _, activeSym, _, _, _, err := h.getSessionData(ctx, sessionId)
+	if err != nil {
+		return res, nil
+	}
+
 	// Read vouchers from the store
 	voucherData, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_VOUCHER_SYMBOLS)
 	logg.InfoCtxf(ctx, "reading voucherData in GetVoucherList", "sessionId", sessionId, "key", storedb.DATA_VOUCHER_SYMBOLS, "voucherData", voucherData)
@@ -191,6 +272,11 @@ func (h *MenuHandlers) GetVoucherList(ctx context.Context, sym string, input []b
 		return res, err
 	}
 
+	if len(voucherData) == 0 {
+		res.Content = l.Get("Your active voucher %s is already set", string(activeSym))
+		return res, nil
+	}
+
 	voucherBalances, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_VOUCHER_BALANCES)
 	logg.InfoCtxf(ctx, "reading voucherBalances in GetVoucherList", "sessionId", sessionId, "key", storedb.DATA_VOUCHER_BALANCES, "voucherBalances", voucherBalances)
 	if err != nil {
@@ -203,7 +289,7 @@ func (h *MenuHandlers) GetVoucherList(ctx context.Context, sym string, input []b
 
 	logg.InfoCtxf(ctx, "final output for GetVoucherList", "sessionId", sessionId, "finalOutput", finalOutput)
 
-	res.Content = finalOutput
+	res.Content = l.Get("Select number or symbol from your vouchers:\n%s", finalOutput)
 
 	return res, nil
 }

handlers/local.go

@@ -81,6 +81,7 @@ func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService)
 	ls.DbRs.AddLocalFunc("check_account_status", appHandlers.CheckAccountStatus)
 	ls.DbRs.AddLocalFunc("authorize_account", appHandlers.Authorize)
 	ls.DbRs.AddLocalFunc("quit", appHandlers.Quit)
+	ls.DbRs.AddLocalFunc("calc_credit_debt", appHandlers.CalculateCreditAndDebt)
 	ls.DbRs.AddLocalFunc("check_balance", appHandlers.CheckBalance)
 	ls.DbRs.AddLocalFunc("validate_recipient", appHandlers.ValidateRecipient)
 	ls.DbRs.AddLocalFunc("transaction_reset", appHandlers.TransactionReset)
@@ -146,6 +147,13 @@ func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService)
 	ls.DbRs.AddLocalFunc("send_mpesa_min_limit", appHandlers.SendMpesaMinLimit)
 	ls.DbRs.AddLocalFunc("send_mpesa_preview", appHandlers.SendMpesaPreview)
 	ls.DbRs.AddLocalFunc("initiate_send_mpesa", appHandlers.InitiateSendMpesa)
+	ls.DbRs.AddLocalFunc("calculate_max_pay_debt", appHandlers.CalculateMaxPayDebt)
+	ls.DbRs.AddLocalFunc("confirm_debt_removal", appHandlers.ConfirmDebtRemoval)
+	ls.DbRs.AddLocalFunc("initiate_pay_debt", appHandlers.InitiatePayDebt)
+	ls.DbRs.AddLocalFunc("get_ordered_vouchers", appHandlers.GetOrderedVouchers)
+	ls.DbRs.AddLocalFunc("pool_deposit_max_amount", appHandlers.PoolDepositMaxAmount)
+	ls.DbRs.AddLocalFunc("confirm_pool_deposit", appHandlers.ConfirmPoolDeposit)
+	ls.DbRs.AddLocalFunc("initiate_pool_deposit", appHandlers.InitiatePoolDeposit)
 
 	ls.first = appHandlers.Init
 

services/registration/calculate_max_pay_debt

@@ -0,0 +1 @@
+{{.calculate_max_pay_debt}}

services/registration/calculate_max_pay_debt.vis

@@ -0,0 +1,10 @@
+LOAD reset_transaction_amount 10
+RELOAD reset_transaction_amount
+MAP calculate_max_pay_debt
+MOUT back 0
+HALT
+LOAD confirm_debt_removal 140
+RELOAD confirm_debt_removal
+CATCH invalid_pay_debt_amount flag_invalid_amount 1
+INCMP _ 0
+INCMP confirm_debt_removal *

services/registration/confirm_debt_removal

@@ -0,0 +1,2 @@
+{{.confirm_debt_removal}}
+Enter your PIN:

services/registration/confirm_debt_removal.vis

@@ -0,0 +1,10 @@
+MAP confirm_debt_removal
+MOUT back 0
+MOUT quit 9
+HALT
+LOAD authorize_account 6
+RELOAD authorize_account
+CATCH incorrect_pin flag_incorrect_pin 1
+INCMP _ 0
+INCMP quit 9
+INCMP initiate_pay_debt *

services/registration/deposit_menu

@@ -0,0 +1 @@
+Pool deposit

services/registration/deposit_menu_swa

@@ -0,0 +1 @@
+Weka kwa bwawa

services/registration/get_mpesa

@@ -1 +1 @@
-{{.get_mpesa_max_limit}}
+{{.get_ordered_vouchers}}

services/registration/get_mpesa.vis

@@ -1,10 +1,15 @@
 CATCH no_voucher flag_no_active_voucher 1
+LOAD get_ordered_vouchers 0
+MAP get_ordered_vouchers
+MOUT back 0
+MOUT quit 99
+MNEXT next 88
+MPREV prev 98
+HALT
+INCMP > 88
+INCMP < 98
+INCMP _ 0
+INCMP quit 99
 LOAD get_mpesa_max_limit 0
 RELOAD get_mpesa_max_limit
-MAP get_mpesa_max_limit
-MOUT back 0
-MOUT quit 9
-HALT
-INCMP _ 0
-INCMP quit 9
-INCMP get_mpesa_confirmation *
+INCMP mpesa_max_limit *

services/registration/get_mpesa_confirmation.vis

@@ -1,7 +1,4 @@
-LOAD get_mpesa_preview 0
 MAP get_mpesa_preview
-CATCH api_failure flag_api_call_error 1
-CATCH invalid_credit_send_amount flag_invalid_amount 1
 MOUT back 0
 MOUT quit 9
 HALT

services/registration/get_mpesa_menu

@@ -1 +1 @@
-Get M-Pesa
+Withdraw

services/registration/initiate_pay_debt.vis

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

services/registration/invalid_get_mpesa_amount

@@ -0,0 +1 @@
+Amount {{.get_mpesa_preview}} is invalid, please try again:

services/registration/invalid_get_mpesa_amount.vis

@@ -0,0 +1,7 @@
+MAP get_mpesa_preview
+RELOAD reset_transaction_amount
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP _ 1
+INCMP quit 9

services/registration/invalid_get_mpesa_amount_swa

@@ -0,0 +1 @@
+Kiwango {{.get_mpesa_preview}} sio sahihi, tafadhali weka tena:

services/registration/invalid_pay_debt_amount

@@ -0,0 +1 @@
+Amount {{.confirm_debt_removal}} is invalid, please try again:

services/registration/invalid_pay_debt_amount.vis

@@ -0,0 +1,7 @@
+MAP confirm_debt_removal
+RELOAD reset_transaction_amount
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP _ 1
+INCMP quit 9

services/registration/invalid_pay_debt_amount_swa

@@ -0,0 +1 @@
+Kiwango {{.confirm_debt_removal}} sio sahihi, tafadhali weka tena:

services/registration/invalid_pool_deposit_amount

@@ -0,0 +1 @@
+Amount {{.confirm_pool_deposit}} is invalid, please try again:

services/registration/invalid_pool_deposit_amount.vis

@@ -0,0 +1,7 @@
+MAP confirm_pool_deposit
+RELOAD reset_transaction_amount
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP _ 1
+INCMP quit 9

services/registration/invalid_pool_deposit_amount_swa

@@ -0,0 +1 @@
+Kiwango {{.confirm_pool_deposit}} sio sahihi, tafadhali weka tena:

services/registration/locale/swa/default.po

@@ -32,7 +32,7 @@ msgid "Symbol: %s\nBalance: %s"
 msgstr "Sarafu: %s\nSalio: %s"
 
 msgid "Your request has been sent. You will receive an SMS when your %s %s has been swapped for %s."
-msgstr "Ombi lako limetumwa. Utapokea SMS wakati %s %s yako itakapobadilishwa kuwa %s."
+msgstr "Ombi lako limetumwa. Utapokea ujumbe wakati %s %s yako itakapobadilishwa kuwa %s."
 
 msgid "%s balance: %s\n"
 msgstr "%s salio: %s\n"
@@ -61,8 +61,8 @@ msgstr "Weka kiasi cha M-Pesa cha kupata: (Kikomo %s Ksh)\n"
 msgid "You are sending %s %s in order to receive ~ %s ksh"
 msgstr "Unatuma ~ %s %s ili upoke %s ksh"
 
-msgid "Your request has been sent. You will receive ~ %s ksh"
-msgstr "Ombi lako limetumwa. Utapokea ~ %s ksh"
+msgid "Your request has been sent. Please await confirmation"
+msgstr "Ombi lako limetumwa. Tafadhali subiri"
 
 msgid "Enter the amount of M-Pesa to send: (Minimum %s Ksh)\n"
 msgstr "Weka kiasi cha M-Pesa cha kutuma: (Kima cha chini %s Ksh)\n"
@@ -72,3 +72,21 @@ msgstr "Utapokea kidokezo cha PIN yako ya M-Pesa hivi karibuni kutuma %s ksh na
 
 msgid "Your request has been sent. Thank you for using Sarafu"
 msgstr "Ombi lako limetumwa. Asante kwa kutumia huduma ya Sarafu"
+
+msgid "You can remove a maximum of %s %s from '%s' pool\n\nEnter amount of %s:"
+msgstr "Unaweza kuondoa kiwango cha juu cha %s %s kutoka kwenye '%s'\n\nWeka kiwango cha %s:"
+
+msgid "Please confirm that you will use %s %s to remove your debt of %s %s\n"
+msgstr "Tafadhali thibitisha kwamba utatumia %s %s kulipa deni lako la %s %s.\nWeka PIN yako:"
+
+msgid "Your active voucher %s is already set"
+msgstr "Sarafu yako %s ishachaguliwa"
+
+msgid "Select number or symbol from your vouchers:\n%s"
+msgstr "Chagua nambari au ishara kutoka kwa sarafu zako:\n%s"
+
+msgid "You will deposit %s %s into %s\n"
+msgstr "Utaweka %s %s kwenye %s\n"
+
+msgid "Your request has been sent. You will receive an SMS when %s %s has been deposited into %s."
+msgstr "Ombi lako limetumwa. Utapokea ujumbe wakati %s %s itawekwa kwenye %s."

services/registration/low_pay_debt_amount

@@ -0,0 +1 @@
+You have a low debt amount

services/registration/low_pay_debt_amount.vis

@@ -0,0 +1,5 @@
+MOUT back 0
+MOUT quit 9
+HALT
+INCMP ^ 0
+INCMP quit 9

services/registration/low_pay_debt_amount_swa

@@ -0,0 +1 @@
+Kiasi cha deni lako ni cha chini sana

services/registration/main.vis

@@ -3,7 +3,7 @@ RELOAD clear_temporary_value
 LOAD manage_vouchers 160
 RELOAD manage_vouchers
 CATCH api_failure flag_api_call_error 1
-LOAD check_balance 128
+LOAD check_balance 148
 RELOAD check_balance
 MAP check_balance
 MOUT send 1

services/registration/mpesa

@@ -1 +1 @@
-{{.check_balance}}
+{{.calc_credit_debt}}

services/registration/mpesa.vis

@@ -1,9 +1,18 @@
-MAP check_balance
-MOUT get_mpesa 1
-MOUT send_mpesa 2
+LOAD calc_credit_debt 150
+RELOAD calc_credit_debt
+CATCH api_failure flag_api_call_error 1
+MAP calc_credit_debt
+MOUT pay_debt 1
+MOUT deposit 2
+MOUT get_mpesa 3
+MOUT send_mpesa 4
+MOUT back 0
 MOUT quit 9
 HALT
-INCMP get_mpesa 1
-INCMP send_mpesa 2
+INCMP ^ 0
+INCMP pay_debt 1
+INCMP pool_deposit 2
+INCMP get_mpesa 3
+INCMP send_mpesa 4
 INCMP quit 9
 INCMP . *

services/registration/mpesa_max_limit

@@ -0,0 +1 @@
+{{.get_mpesa_max_limit}}

services/registration/mpesa_max_limit.vis

@@ -0,0 +1,13 @@
+LOAD reset_transaction_amount 10
+RELOAD reset_transaction_amount
+MAP get_mpesa_max_limit
+MOUT back 0
+MOUT quit 9
+HALT
+INCMP _ 0
+INCMP quit 9
+LOAD get_mpesa_preview 90
+RELOAD get_mpesa_preview
+CATCH api_failure flag_api_call_error 1
+CATCH invalid_get_mpesa_amount flag_invalid_amount 1
+INCMP get_mpesa_confirmation *

services/registration/no_stable_voucher

@@ -0,0 +1 @@
+No stable voucher found

services/registration/no_stable_voucher.vis

@@ -0,0 +1,5 @@
+MOUT back 0
+MOUT quit 9
+HALT
+INCMP ^ 0
+INCMP quit 9

services/registration/no_stable_voucher_swa

@@ -0,0 +1 @@
+Hakuna sarafu thabiti iliyopatikana

services/registration/pay_debt

@@ -0,0 +1 @@
+{{.get_vouchers}}

services/registration/pay_debt.vis

@@ -0,0 +1,16 @@
+CATCH no_voucher flag_no_active_voucher 1
+LOAD get_vouchers 0
+MAP get_vouchers
+MOUT back 0
+MOUT quit 99
+MNEXT next 88
+MPREV prev 98
+HALT
+INCMP > 88
+INCMP < 98
+INCMP _ 0
+INCMP quit 99
+LOAD calculate_max_pay_debt 0
+RELOAD calculate_max_pay_debt
+CATCH . flag_incorrect_voucher 1
+INCMP calculate_max_pay_debt *

services/registration/pay_debt_menu

@@ -0,0 +1 @@
+Pay debt

services/registration/pay_debt_menu_swa

@@ -0,0 +1 @@
+Lipa deni

services/registration/pay_debt_swa

@@ -0,0 +1 @@
+{{.calculate_max_pay_debt}}

services/registration/pool_deposit

@@ -0,0 +1 @@
+{{.get_ordered_vouchers}}

services/registration/pool_deposit.vis

@@ -0,0 +1,17 @@
+CATCH no_voucher flag_no_active_voucher 1
+CATCH no_stable_voucher flag_no_stable_vouchers 1
+LOAD get_ordered_vouchers 0
+MAP get_ordered_vouchers
+MOUT back 0
+MOUT quit 99
+MNEXT next 88
+MPREV prev 98
+HALT
+INCMP > 88
+INCMP < 98
+INCMP _ 0
+INCMP quit 99
+LOAD pool_deposit_max_amount 120
+RELOAD pool_deposit_max_amount
+CATCH . flag_incorrect_voucher 1
+INCMP pool_deposit_amount *

services/registration/pool_deposit_amount

@@ -0,0 +1 @@
+{{.pool_deposit_max_amount}}

services/registration/pool_deposit_amount.vis

@@ -0,0 +1,10 @@
+LOAD reset_transaction_amount 10
+RELOAD reset_transaction_amount
+MAP pool_deposit_max_amount
+MOUT back 0
+HALT
+LOAD confirm_pool_deposit 140
+RELOAD confirm_pool_deposit
+CATCH invalid_pool_deposit_amount flag_invalid_amount 1
+INCMP _ 0
+INCMP pool_deposit_confirmation *

services/registration/pool_deposit_confirmation

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

services/registration/pool_deposit_confirmation.vis

@@ -0,0 +1,10 @@
+MAP confirm_pool_deposit
+MOUT back 0
+MOUT quit 9
+HALT
+LOAD authorize_account 6
+RELOAD authorize_account
+CATCH incorrect_pin flag_incorrect_pin 1
+INCMP _ 0
+INCMP quit 9
+INCMP pool_deposit_initiated *

services/registration/pool_deposit_confirmation_swa

@@ -0,0 +1,2 @@
+{{.confirm_pool_deposit}}
+Tafadhali weka PIN yako kudhibitisha:

services/registration/pool_deposit_initiated.vis

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

services/registration/pp.csv

@@ -36,3 +36,4 @@ 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
+flag,flag_no_stable_vouchers,46,this is set when the user does not have a stable voucher

services/registration/root.vis

@@ -7,7 +7,7 @@ CATCH blocked_account flag_account_blocked 1
 CATCH select_language flag_language_set 0
 CATCH terms flag_account_created 0
 CATCH create_pin flag_pin_set 0
-LOAD check_account_status 0
+LOAD check_account_status 40
 RELOAD check_account_status
 CATCH api_failure flag_api_call_error 1
 CATCH account_pending flag_account_pending 1

services/registration/select_voucher

@@ -1,2 +1 @@
-Select number or symbol from your vouchers:
 {{.get_vouchers}}

services/registration/select_voucher_swa

@@ -1,2 +0,0 @@
-Chagua nambari au ishara kutoka kwa salio zako:
-{{.get_vouchers}}

services/registration/send_mpesa_menu

@@ -1 +1 @@
-Send M-Pesa
+Top-up

store/db/db.go

@@ -93,6 +93,8 @@ const (
 	DATA_SEND_TRANSACTION_TYPE
 	// Holds the recipient formatted phone number
 	DATA_RECIPIENT_PHONE_NUMBER
+	// Currently active swap from balance for the swap
+	DATA_ACTIVE_SWAP_FROM_BALANCE
 )
 
 const (
@@ -104,7 +106,14 @@ const (
 	DATA_VOUCHER_DECIMALS
 	// List of voucher EVM addresses for vouchers valid in the user context.
 	DATA_VOUCHER_ADDRESSES
-	// List of senders for valid transactions in the user context.
+	// List of ordered voucher symbols in the user context.
+	DATA_ORDERED_VOUCHER_SYMBOLS
+	// List of ordered voucher balances in the user context.
+	DATA_ORDERED_VOUCHER_BALANCES
+	// List of ordered voucher decimals in the user context.
+	DATA_ORDERED_VOUCHER_DECIMALS
+	// List of ordered voucher EVM addresses in the user context.
+	DATA_ORDERED_VOUCHER_ADDRESSES
 )
 
 const (

store/swap.go

@@ -18,6 +18,7 @@ type SwapData struct {
 	ActiveSwapFromAddress string
 	ActiveSwapToSym       string
 	ActiveSwapToAddress   string
+	ActiveSwapToDecimal   string
 }
 
 type SwapPreviewData struct {
@@ -43,6 +44,7 @@ func ReadSwapData(ctx context.Context, store DataStore, sessionId string) (SwapD
 		"ActiveSwapFromAddress": storedb.DATA_ACTIVE_ADDRESS,
 		"ActiveSwapToSym":       storedb.DATA_ACTIVE_SWAP_TO_SYM,
 		"ActiveSwapToAddress":   storedb.DATA_ACTIVE_SWAP_TO_ADDRESS,
+		"ActiveSwapToDecimal":   storedb.DATA_ACTIVE_SWAP_TO_DECIMAL,
 	}
 
 	v := reflect.ValueOf(&data).Elem()
@@ -187,3 +189,50 @@ func UpdateSwapToVoucherData(ctx context.Context, store DataStore, sessionId str
 
 	return nil
 }
+
+// UpdateSwapFromVoucherData updates the active swap from voucher data in the DataStore.
+func UpdateSwapFromVoucherData(ctx context.Context, store DataStore, sessionId string, data *dataserviceapi.TokenHoldings) error {
+	logg.InfoCtxf(ctx, "UpdateSwapFromVoucherData", "data", data)
+	// Active swap to voucher data entries
+	activeEntries := map[storedb.DataTyp][]byte{
+		storedb.DATA_ACTIVE_SWAP_FROM_SYM:     []byte(data.TokenSymbol),
+		storedb.DATA_ACTIVE_SWAP_FROM_DECIMAL: []byte(data.TokenDecimals),
+		storedb.DATA_ACTIVE_SWAP_FROM_ADDRESS: []byte(data.TokenAddress),
+		storedb.DATA_ACTIVE_SWAP_FROM_BALANCE: []byte(data.Balance),
+	}
+
+	// Write active data
+	for key, value := range activeEntries {
+		if err := store.WriteEntry(ctx, sessionId, key, value); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// ReadSwapFromVoucher retrieves the voucher being swapped into the pool (swap from)
+func ReadSwapFromVoucher(ctx context.Context, store DataStore, sessionId string) (*dataserviceapi.TokenHoldings, error) {
+	keys := []storedb.DataTyp{
+		storedb.DATA_ACTIVE_SWAP_FROM_SYM,
+		storedb.DATA_ACTIVE_SWAP_FROM_DECIMAL,
+		storedb.DATA_ACTIVE_SWAP_FROM_ADDRESS,
+		storedb.DATA_ACTIVE_SWAP_FROM_BALANCE,
+	}
+	data := make(map[storedb.DataTyp]string)
+
+	for _, key := range keys {
+		value, err := store.ReadEntry(ctx, sessionId, key)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get data key %x: %v", key, err)
+		}
+		data[key] = string(value)
+	}
+
+	return &dataserviceapi.TokenHoldings{
+		TokenSymbol:   data[storedb.DATA_ACTIVE_SWAP_FROM_SYM],
+		Balance:       data[storedb.DATA_ACTIVE_SWAP_FROM_BALANCE],
+		TokenDecimals: data[storedb.DATA_ACTIVE_SWAP_FROM_DECIMAL],
+		TokenAddress:  data[storedb.DATA_ACTIVE_SWAP_FROM_ADDRESS],
+	}, nil
+}

store/vouchers.go

@@ -120,6 +120,43 @@ func GetVoucherData(ctx context.Context, store DataStore, sessionId string, inpu
 	}, nil
 }
 
+// GetOrderedVoucherData retrieves and matches ordered voucher data
+func GetOrderedVoucherData(ctx context.Context, store DataStore, sessionId string, input string) (*dataserviceapi.TokenHoldings, error) {
+	keys := []storedb.DataTyp{
+		storedb.DATA_ORDERED_VOUCHER_SYMBOLS,
+		storedb.DATA_ORDERED_VOUCHER_BALANCES,
+		storedb.DATA_ORDERED_VOUCHER_DECIMALS,
+		storedb.DATA_ORDERED_VOUCHER_ADDRESSES,
+	}
+	data := make(map[storedb.DataTyp]string)
+
+	for _, key := range keys {
+		value, err := store.ReadEntry(ctx, sessionId, key)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get data key %x: %v", key, err)
+		}
+		data[key] = string(value)
+	}
+
+	symbol, balance, decimal, address := MatchVoucher(input,
+		data[storedb.DATA_ORDERED_VOUCHER_SYMBOLS],
+		data[storedb.DATA_ORDERED_VOUCHER_BALANCES],
+		data[storedb.DATA_ORDERED_VOUCHER_DECIMALS],
+		data[storedb.DATA_ORDERED_VOUCHER_ADDRESSES],
+	)
+
+	if symbol == "" {
+		return nil, nil
+	}
+
+	return &dataserviceapi.TokenHoldings{
+		TokenSymbol:   string(symbol),
+		Balance:       string(balance),
+		TokenDecimals: string(decimal),
+		TokenAddress:  string(address),
+	}, nil
+}
+
 // MatchVoucher finds the matching voucher symbol, balance, decimals and contract address based on the input.
 func MatchVoucher(input, symbols, balances, decimals, addresses string) (symbol, balance, decimal, address string) {
 	symList := strings.Split(symbols, "\n")
@@ -225,3 +262,46 @@ func FormatVoucherList(ctx context.Context, symbolsData, balancesData string) []
 	}
 	return combined
 }
+
+// AddDecimalStrings adds two decimal numbers represented as strings
+// and returns the result as a string without losing precision.
+func AddDecimalStrings(a, b string) string {
+	x, ok := new(big.Rat).SetString(a)
+	if !ok {
+		x = new(big.Rat)
+	}
+
+	y, ok := new(big.Rat).SetString(b)
+	if !ok {
+		y = new(big.Rat)
+	}
+
+	x.Add(x, y)
+
+	// Convert back to string without scientific notation
+	return x.FloatString(maxDecimalPlaces(x, y))
+}
+
+// maxDecimalPlaces ensures we preserve enough decimal precision
+func maxDecimalPlaces(rats ...*big.Rat) int {
+	max := 0
+	for _, r := range rats {
+		if r == nil {
+			continue
+		}
+		if d := decimalPlaces(r); d > max {
+			max = d
+		}
+	}
+	return max
+}
+
+func decimalPlaces(r *big.Rat) int {
+	s := r.FloatString(18)
+	for i := len(s) - 1; i >= 0; i-- {
+		if s[i] == '.' {
+			return len(s) - i - 1
+		}
+	}
+	return 0
+}