cmd/main.go

@@ -83,9 +83,9 @@ func main() {
 
 	fp := path.Join(dp, sessionId)
 
-	ussdHandlers, err := ussd.NewHandlers(fp, &st)
+	ussdHandlers,err := ussd.NewHandlers(fp, &st)
 
-	if err != nil {
+	if(err != nil){
 		fmt.Fprintf(os.Stderr, "handler setup failed with error: %v\n", err)
 	}
 

internal/handlers/ussd/menuhandler.go

@@ -3,7 +3,6 @@ package ussd
 import (
 	"bytes"
 	"context"
-	"errors"
 	"fmt"
 	"path"
 	"regexp"
@@ -17,74 +16,46 @@ import (
 	"git.defalsify.org/vise.git/state"
 	"git.grassecon.net/urdt/ussd/internal/handlers/server"
 	"git.grassecon.net/urdt/ussd/internal/utils"
-	"github.com/graygnuorg/go-gdbm"
 	"gopkg.in/leonelquinteros/gotext.v1"
 )
 
 var (
 	scriptDir      = path.Join("services", "registration")
 	translationDir = path.Join(scriptDir, "locale")
-	dbFile         = path.Join(scriptDir, "vise.gdbm")
 )
 
-const (
-	TrackingIdKey  = "TRACKINGID"
-	PublicKeyKey   = "PUBLICKEY"
-	CustodialIdKey = "CUSTODIALID"
-	AccountPin     = "ACCOUNTPIN"
-	AccountStatus  = "ACCOUNTSTATUS"
-	FirstName      = "FIRSTNAME"
-	FamilyName     = "FAMILYNAME"
-	YearOfBirth    = "YOB"
-	Location       = "LOCATION"
-	Gender         = "GENDER"
-	Offerings      = "OFFERINGS"
-	Recipient      = "RECIPIENT"
-	Amount         = "AMOUNT"
-)
-
-func toBytes(s string) []byte {
-	return []byte(s)
-}
-
 type FSData struct {
 	Path string
 	St   *state.State
 }
 
 type FlagParserInterface interface {
-	GetFlag(key string) (uint32, error)
+    GetFlag(key string) (uint32, error)
 }
 
 type Handlers struct {
 	fs                 *FSData
-	db                 *gdbm.Database
 	parser             FlagParserInterface
 	accountFileHandler utils.AccountFileHandlerInterface
 	accountService     server.AccountServiceInterface
 }
 
 func NewHandlers(dir string, st *state.State) (*Handlers, error) {
-	db, err := gdbm.Open(dbFile, gdbm.ModeWrcreat)
+    pfp := path.Join(scriptDir, "pp.csv")
-	if err != nil {
+    parser := asm.NewFlagParser()
-		panic(err)
+    _, err := parser.Load(pfp)
-	}
+    if err != nil {
-	pfp := path.Join(scriptDir, "pp.csv")
+        return nil, err
-	parser := asm.NewFlagParser()
+    }
-	_, err = parser.Load(pfp)
+    return &Handlers{
-	if err != nil {
+        fs: &FSData{
-		return nil, err
+            Path: dir,
-	}
+            St:   st,
-	return &Handlers{
+        },
-		db: db,
+        parser:             parser, 
-		fs: &FSData{
+        accountFileHandler: utils.NewAccountFileHandler(dir + "_data"),
-			Path: dir,
+        accountService:     &server.AccountService{},
-			St:   st,
+    }, nil
-		},
-		parser:             parser,
-		accountFileHandler: utils.NewAccountFileHandler(dir + "_data"),
-		accountService:     &server.AccountService{},
-	}, nil
 }
 
 // Define the regex pattern as a constant
@@ -164,18 +135,22 @@ func (h *Handlers) CreateAccount(ctx context.Context, sym string, input []byte)
 		res.FlagSet = append(res.FlagSet, flags["flag_account_creation_failed"])
 		return res, err
 	}
-	data := map[string]string{
+
-		TrackingIdKey:  accountResp.Result.TrackingId,
+	accountData := map[string]string{
-		PublicKeyKey:   accountResp.Result.PublicKey,
+		"TrackingId":  accountResp.Result.TrackingId,
-		CustodialIdKey: accountResp.Result.CustodialId.String(),
+		"PublicKey":   accountResp.Result.PublicKey,
+		"CustodialId": accountResp.Result.CustodialId.String(),
+		"Status":      "PENDING",
+		"Gender":      "Not provided",
+		"YOB":         "Not provided",
+		"Location":    "Not provided",
+		"Offerings":   "Not provided",
+		"FirstName":   "Not provided",
+		"FamilyName":  "Not provided",
 	}
-
+	err = h.accountFileHandler.WriteAccountData(accountData)
-	for key, value := range data {
+	if err != nil {
-		err := h.db.Store(toBytes(key), toBytes(value), true)
+		return res, err
-		if err != nil {
-			return res, err
-
-		}
 	}
 
 	res.FlagSet = append(res.FlagSet, flags["flag_account_created"])
@@ -185,6 +160,8 @@ func (h *Handlers) CreateAccount(ctx context.Context, sym string, input []byte)
 // SavePin persists the user's PIN choice into the filesystem
 func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
+
+	// Preload the required flags
 	flagKeys := []string{"flag_incorrect_pin"}
 	flags, err := h.PreloadFlags(flagKeys)
 	if err != nil {
@@ -193,10 +170,10 @@ func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resou
 
 	accountPIN := string(input)
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
+		return res, err
-	// }
+	}
 
 	// Validate that the PIN is a 4-digit number
 	if !isValidPIN(accountPIN) {
@@ -205,17 +182,12 @@ func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resou
 	}
 
 	res.FlagReset = append(res.FlagReset, flags["flag_incorrect_pin"])
-	//accountData["AccountPIN"] = accountPIN
+	accountData["AccountPIN"] = accountPIN
 
-	key := []byte(AccountPin)
+	err = h.accountFileHandler.WriteAccountData(accountData)
-	value := []byte(accountPIN)
+	if err != nil {
-
+		return res, err
-	h.db.Store(key, value, true)
+	}
-
-	// err = h.accountFileHandler.WriteAccountData(accountData)
-	// if err != nil {
-	// 	return res, err
-	// }
 
 	return res, nil
 }
@@ -293,23 +265,18 @@ func codeFromCtx(ctx context.Context) string {
 func (h *Handlers) SaveFirstname(cxt context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
+		return res, err
-	// }
+	}
 	if len(input) > 0 {
 		name := string(input)
-		//accountData["FirstName"] = name
+		accountData["FirstName"] = name
 
-		key := []byte(FirstName)
+		err = h.accountFileHandler.WriteAccountData(accountData)
-		value := []byte(name)
+		if err != nil {
-
+			return res, err
-		h.db.Store(key, value, true)
+		}
-
-		// err = h.accountFileHandler.WriteAccountData(accountData)
-		// if err != nil {
-		// 	return res, err
-		// }
 	}
 
 	return res, nil
@@ -318,12 +285,19 @@ func (h *Handlers) SaveFirstname(cxt context.Context, sym string, input []byte)
 // SaveFamilyname updates the family name in a JSON data file with the provided input.
 func (h *Handlers) SaveFamilyname(cxt context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
+
+	accountData, err := h.accountFileHandler.ReadAccountData()
+	if err != nil {
+		return res, err
+	}
 	if len(input) > 0 {
 		secondname := string(input)
-		key := []byte(FamilyName)
+		accountData["FamilyName"] = secondname
-		value := []byte(secondname)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
+		if err != nil {
+			return res, err
+		}
 	}
 
 	return res, nil
@@ -333,18 +307,20 @@ func (h *Handlers) SaveFamilyname(cxt context.Context, sym string, input []byte)
 func (h *Handlers) SaveYob(cxt context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
+	accountData, err := h.accountFileHandler.ReadAccountData()
+	if err != nil {
+		return res, err
+	}
+
 	yob := string(input)
 	if len(yob) == 4 {
 		yob := string(input)
-		//accountData["YOB"] = yob
+		accountData["YOB"] = yob
-		key := []byte(YearOfBirth)
-		value := []byte(yob)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
-		// err = h.accountFileHandler.WriteAccountData(accountData)
+		if err != nil {
-		// if err != nil {
+			return res, err
-		// 	return res, err
+		}
-		// }
 	}
 
 	return res, nil
@@ -354,17 +330,19 @@ func (h *Handlers) SaveYob(cxt context.Context, sym string, input []byte) (resou
 func (h *Handlers) SaveLocation(cxt context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
+		return res, err
-	// }
+	}
 
 	if len(input) > 0 {
 		location := string(input)
-		key := []byte(Location)
+		accountData["Location"] = location
-		value := []byte(location)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
+		if err != nil {
+			return res, err
+		}
 	}
 
 	return res, nil
@@ -373,6 +351,12 @@ func (h *Handlers) SaveLocation(cxt context.Context, sym string, input []byte) (
 // SaveGender updates the gender in a JSON data file with the provided input.
 func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
+
+	accountData, err := h.accountFileHandler.ReadAccountData()
+	if err != nil {
+		return res, err
+	}
+
 	if len(input) > 0 {
 		gender := string(input)
 
@@ -384,16 +368,12 @@ func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (re
 		case "3":
 			gender = "Unspecified"
 		}
-		//accountData["Gender"] = gender
+		accountData["Gender"] = gender
-		key := []byte(Gender)
-		value := []byte(gender)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
-
+		if err != nil {
-		// err = h.accountFileHandler.WriteAccountData(accountData)
+			return res, err
-		// if err != nil {
+		}
-		// 	return res, err
-		// }
 	}
 	return res, nil
 }
@@ -402,23 +382,19 @@ func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (re
 func (h *Handlers) SaveOfferings(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
+		return res, err
-	// }
+	}
 
 	if len(input) > 0 {
 		offerings := string(input)
-		//accountData["Offerings"] = offerings
+		accountData["Offerings"] = offerings
-		key := []byte(Offerings)
-		value := []byte(offerings)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
-
+		if err != nil {
-		// err = h.accountFileHandler.WriteAccountData(accountData)
+			return res, err
-		// if err != nil {
+		}
-		// 	return res, err
-		// }
 	}
 	return res, nil
 }
@@ -457,16 +433,12 @@ func (h *Handlers) ResetAccountAuthorized(ctx context.Context, sym string, input
 func (h *Handlers) CheckIdentifier(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
-	// 	return res, err
-	// }
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
 	if err != nil {
 		return res, err
 	}
 
-	res.Content = string(publicKey)
+	res.Content = accountData["PublicKey"]
 
 	return res, nil
 }
@@ -483,35 +455,27 @@ func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (res
 		return res, err
 	}
 
-	// pin := string(input)
+	pin := string(input)
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
-	// }
-
-	storedpin, err := h.db.Fetch([]byte(AccountPin))
-	if err == nil {
-		if len(input) == 4 {
-			if bytes.Equal(input, storedpin) {
-				if h.fs.St.MatchFlag(flags["flag_account_authorized"], false) {
-					res.FlagReset = append(res.FlagReset, flags["flag_incorrect_pin"])
-					res.FlagSet = append(res.FlagSet, flags["flag_allow_update"], flags["flag_account_authorized"])
-				} else {
-					res.FlagSet = append(res.FlagSet, flags["flag_allow_update"])
-					res.FlagReset = append(res.FlagReset, flags["flag_account_authorized"])
-				}
-			} else {
-				res.FlagSet = append(res.FlagSet, flags["flag_incorrect_pin"])
-				res.FlagReset = append(res.FlagReset, flags["flag_account_authorized"])
-				return res, nil
-			}
-		}
-	} else if errors.Is(err, gdbm.ErrItemNotFound) {
-		//PIN not set yet
-	} else {
 		return res, err
 	}
+
+	if len(input) == 4 {
+		if pin != accountData["AccountPIN"] {
+			res.FlagSet = append(res.FlagSet, flags["flag_incorrect_pin"])
+			res.FlagReset = append(res.FlagReset, flags["flag_account_authorized"])
+			return res, nil
+		}
+		if h.fs.St.MatchFlag(flags["flag_account_authorized"], false) {
+			res.FlagReset = append(res.FlagReset, flags["flag_incorrect_pin"])
+			res.FlagSet = append(res.FlagSet, flags["flag_allow_update"], flags["flag_account_authorized"])
+		} else {
+			res.FlagSet = append(res.FlagSet, flags["flag_allow_update"])
+			res.FlagReset = append(res.FlagReset, flags["flag_account_authorized"])
+		}
+	}
 	return res, nil
 }
 
@@ -542,31 +506,20 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b
 		return res, err
 	}
 
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
-	// 	return res, err
-	// }
-	trackingId, err := h.db.Fetch([]byte(TrackingIdKey))
-
 	if err != nil {
 		return res, err
 	}
 
-	status, err := h.accountService.CheckAccountStatus(string(trackingId))
+	status, err := h.accountService.CheckAccountStatus(accountData["TrackingId"])
 
 	if err != nil {
 		fmt.Println("Error checking account status:", err)
-		return res, err
-
-	}
-
-	//accountData["Status"] = status
-	err = h.db.Store(toBytes(TrackingIdKey), toBytes(status), true)
-
-	if err != nil {
 		return res, nil
 	}
 
+	accountData["Status"] = status
+
 	if status == "SUCCESS" {
 		res.FlagSet = append(res.FlagSet, flags["flag_account_success"])
 		res.FlagReset = append(res.FlagReset, flags["flag_account_pending"])
@@ -575,10 +528,10 @@ func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []b
 		res.FlagSet = append(res.FlagReset, flags["flag_account_pending"])
 	}
 
-	// err = h.accountFileHandler.WriteAccountData(accountData)
+	err = h.accountFileHandler.WriteAccountData(accountData)
-	// if err != nil {
+	if err != nil {
-	// 	return res, err
+		return res, err
-	// }
+	}
 
 	return res, nil
 }
@@ -631,7 +584,7 @@ func (h *Handlers) VerifyYob(ctx context.Context, sym string, input []byte) (res
 	return res, nil
 }
 
-// ResetIncorrectYob resets the incorrect date format flag after a new attempt
+// ResetIncorrectYob resets the incorrect date format after a new attempt
 func (h *Handlers) ResetIncorrectYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
@@ -650,13 +603,13 @@ func (h *Handlers) ResetIncorrectYob(ctx context.Context, sym string, input []by
 // the balance as the result content
 func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
 
+	accountData, err := h.accountFileHandler.ReadAccountData()
 	if err != nil {
 		return res, err
 	}
 
-	balance, err := h.accountService.CheckBalance(string(publicKey))
+	balance, err := h.accountService.CheckBalance(accountData["PublicKey"])
 	if err != nil {
 		return res, nil
 	}
@@ -668,14 +621,21 @@ func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) (
 // ValidateRecipient validates that the given input is a valid phone number.
 func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
-	recipient := string(input)
 
+	// Preload the required flags
 	flagKeys := []string{"flag_invalid_recipient"}
 	flags, err := h.PreloadFlags(flagKeys)
 	if err != nil {
 		return res, err
 	}
 
+	recipient := string(input)
+
+	accountData, err := h.accountFileHandler.ReadAccountData()
+	if err != nil {
+		return res, err
+	}
+
 	if recipient != "0" {
 		// mimic invalid number check
 		if recipient == "000" {
@@ -685,11 +645,12 @@ func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []by
 			return res, nil
 		}
 
-		// accountData["Recipient"] = recipient
+		accountData["Recipient"] = recipient
-		key := []byte(Recipient)
-		value := []byte(recipient)
 
-		h.db.Store(key, value, true)
+		err = h.accountFileHandler.WriteAccountData(accountData)
+		if err != nil {
+			return res, err
+		}
 	}
 
 	return res, nil
@@ -707,13 +668,18 @@ func (h *Handlers) TransactionReset(ctx context.Context, sym string, input []byt
 		return res, err
 	}
 
-	err = h.db.Delete([]byte(Amount))
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) {
+	if err != nil {
-		panic(err)
+		return res, err
 	}
-	err = h.db.Delete([]byte(Recipient))
+
-	if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) {
+	// reset the transaction
-		panic(err)
+	accountData["Recipient"] = ""
+	accountData["Amount"] = ""
+
+	err = h.accountFileHandler.WriteAccountData(accountData)
+	if err != nil {
+		return res, err
 	}
 
 	res.FlagReset = append(res.FlagReset, flags["flag_invalid_recipient"], flags["flag_invalid_recipient_with_invite"])
@@ -732,9 +698,17 @@ func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input
 		return res, err
 	}
 
-	err = h.db.Delete([]byte(Amount))
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	if err != nil && !errors.Is(err, gdbm.ErrItemNotFound) {
+	if err != nil {
-		panic(err)
+		return res, err
+	}
+
+	// reset the amount
+	accountData["Amount"] = ""
+
+	err = h.accountFileHandler.WriteAccountData(accountData)
+	if err != nil {
+		return res, err
 	}
 
 	res.FlagReset = append(res.FlagReset, flags["flag_invalid_amount"])
@@ -746,12 +720,13 @@ func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input
 // the result content.
 func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
+
+	accountData, err := h.accountFileHandler.ReadAccountData()
 	if err != nil {
 		return res, err
 	}
 
-	balance, err := h.accountService.CheckBalance(string(publicKey))
+	balance, err := h.accountService.CheckBalance(accountData["PublicKey"])
 	if err != nil {
 		return res, nil
 	}
@@ -765,6 +740,7 @@ func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (res
 // it is not more than the current balance.
 func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
+
 	// Preload the required flag
 	flagKeys := []string{"flag_invalid_amount"}
 	flags, err := h.PreloadFlags(flagKeys)
@@ -773,14 +749,13 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	}
 
 	amountStr := string(input)
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
 
+	accountData, err := h.accountFileHandler.ReadAccountData()
 	if err != nil {
 		return res, err
 	}
 
-	balanceStr, err := h.accountService.CheckBalance(string(publicKey))
+	balanceStr, err := h.accountService.CheckBalance(accountData["PublicKey"])
-
 	if err != nil {
 		return res, err
 	}
@@ -819,10 +794,9 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 	}
 
 	res.Content = fmt.Sprintf("%.3f", inputAmount) // Format to 3 decimal places
-	key := []byte(Amount)
+	accountData["Amount"] = res.Content
-	value := []byte(res.Content)
-	h.db.Store(key, value, true)
 
+	err = h.accountFileHandler.WriteAccountData(accountData)
 	if err != nil {
 		return res, err
 	}
@@ -833,12 +807,13 @@ func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte)
 // GetRecipient returns the transaction recipient from a JSON data file.
 func (h *Handlers) GetRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
-	recipient, err := h.db.Fetch([]byte(Recipient))
+
+	accountData, err := h.accountFileHandler.ReadAccountData()
 	if err != nil {
 		return res, err
 	}
 
-	res.Content = string(recipient)
+	res.Content = accountData["Recipient"]
 
 	return res, nil
 }
@@ -880,13 +855,12 @@ func (h *Handlers) GetProfileInfo(ctx context.Context, sym string, input []byte)
 func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	//accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
 	if err != nil {
 		return res, err
 	}
 
-	res.Content = string(publicKey)
+	res.Content = accountData["PublicKey"]
 
 	return res, nil
 }
@@ -895,13 +869,12 @@ func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (res
 func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	res := resource.Result{}
 
-	//accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	amount, err := h.db.Fetch([]byte(Amount))
 	if err != nil {
 		return res, err
 	}
 
-	res.Content = string(amount)
+	res.Content = accountData["Amount"]
 
 	return res, nil
 }
@@ -921,15 +894,11 @@ func (h *Handlers) QuitWithBalance(ctx context.Context, sym string, input []byte
 	code := codeFromCtx(ctx)
 	l := gotext.NewLocale(translationDir, code)
 	l.AddDomain("default")
-	// accountData, err := h.accountFileHandler.ReadAccountData()
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// if err != nil {
-	// 	return res, err
-	// }
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
 	if err != nil {
 		return res, err
 	}
-	balance, err := h.accountService.CheckBalance(string(publicKey))
+	balance, err := h.accountService.CheckBalance(accountData["PublicKey"])
 	if err != nil {
 		return res, nil
 	}
@@ -945,29 +914,25 @@ func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input []
 	code := codeFromCtx(ctx)
 	l := gotext.NewLocale(translationDir, code)
 	l.AddDomain("default")
-	// Preload the required flags
+
-	// flagKeys := []string{"flag_invalid_recipient"}
+	accountData, err := h.accountFileHandler.ReadAccountData()
-	// flags, err := h.PreloadFlags(flagKeys)
+	if err != nil {
-	// if err != nil {
+		return res, err
-	// 	return res, err
+	}
-	// }
+
 	// TODO
 	// Use the amount, recipient and sender to call the API and initialize the transaction
 
-	publicKey, err := h.db.Fetch([]byte(PublicKeyKey))
+	res.Content = l.Get("Your request has been sent. %s will receive %s from %s.", accountData["Recipient"], accountData["Amount"], accountData["PublicKey"])
-	if err != nil {
-		return res, err
-	}
-	amount, err := h.db.Fetch([]byte(Amount))
-	if err != nil {
-		return res, err
-	}
-	recipient, err := h.db.Fetch([]byte(Recipient))
-	if err != nil {
-		return res, err
-	}
 
-	res.Content = l.Get("Your request has been sent. %s will receive %s from %s.", string(recipient), string(amount), string(publicKey))
+	// reset the transaction
+	accountData["Recipient"] = ""
+	accountData["Amount"] = ""
+
+	err = h.accountFileHandler.WriteAccountData(accountData)
+	if err != nil {
+		return res, err
+	}
 
 	account_authorized_flag, err := h.parser.GetFlag("flag_account_authorized")