call memory's pop to free cache's current level

Check argument count in devtools admin
Add reset tool
2025-03-27 12:31:46 +03:00 · 2025-03-26 18:28:06 +00:00 · 2025-03-26 18:17:54 +00:00
62 changed files with 902 additions and 751 deletions
--- a/2
+++ b/2
@@ -21,7 +21,7 @@ RUN make VISE_PATH=/build/go-vise -B
 WORKDIR /build/sarafu-vise
 RUN echo "Building on $BUILDPLATFORM, building for $TARGETPLATFORM"
 RUN go mod download
-RUN go build -tags logdebug,online -o sarafu-at -ldflags="-X main.build=${BUILD} -s -w" cmd/africastalking/main.go
+RUN go build -tags logwarn,online -o sarafu-at -ldflags="-X main.build=${BUILD} -s -w" cmd/africastalking/main.go

 FROM debian:bookworm-slim

--- a/cmd/africastalking/main.go
+++ b/cmd/africastalking/main.go
@@ -44,7 +44,6 @@ func main() {
 	var err error
 	var gettextDir string
 	var langs args.LangVar
-	var logDbConnStr string

 	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
 	flag.StringVar(&override.DbConn, "c", "?", "default connection string (replaces all unspecified strings)")
@@ -56,7 +55,6 @@ func main() {
 	flag.UintVar(&port, "p", config.Port(), "http port")
 	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
 	flag.Var(&langs, "language", "add symbol resolution for language")
-	flag.StringVar(&logDbConnStr, "log-c", "db-logs", "log db connection string")
 	flag.Parse()

 	config.Apply(override)
@@ -102,11 +100,6 @@ func main() {
 		fmt.Fprintf(os.Stderr, "userdatadb: %v\n", err)
 		os.Exit(1)
 	}
-	logdb, err := menuStorageService.GetLogDb(ctx, userdataStore, logDbConnStr, "user-data")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "get log db error: %v\n", err)
-		os.Exit(1)
-	}

 	dbResource, ok := rs.(*resource.DbResource)
 	if !ok {
@@ -120,7 +113,6 @@ func main() {
 		os.Exit(1)
 	}
 	lhs.SetDataStore(&userdataStore)
-	lhs.SetLogDb(&logdb)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "setdatastore: %v\n", err)
 		os.Exit(1)
--- a/cmd/async/main.go
+++ b/cmd/async/main.go
@@ -56,7 +56,6 @@ func main() {
 	var err error
 	var gettextDir string
 	var langs args.LangVar
-	var logDbConnStr string

 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&override.DbConn, "c", "?", "default connection string (replaces all unspecified strings)")
@@ -70,7 +69,6 @@ func main() {
 	flag.UintVar(&port, "p", config.Port(), "http port")
 	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
 	flag.Var(&langs, "language", "add symbol resolution for language")
-	flag.StringVar(&logDbConnStr, "log-c", "db-logs", "log db connection string")
 	flag.Parse()

 	config.Apply(override)
@@ -122,12 +120,6 @@ func main() {
 		fmt.Fprintf(os.Stderr, err.Error())
 		os.Exit(1)
 	}
-
-	logdb, err := menuStorageService.GetLogDb(ctx, userdataStore, logDbConnStr, "user-data")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "get log db error: %v\n", err)
-		os.Exit(1)
-	}
 	//defer userdataStore.Close(ctx)

 	dbResource, ok := rs.(*resource.DbResource)
@@ -137,7 +129,6 @@ func main() {

 	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
 	lhs.SetDataStore(&userdataStore)
-	lhs.SetLogDb(&logdb)

 	accountService := services.New(ctx, menuStorageService)
 	hl, err := lhs.GetHandler(accountService)
--- a/cmd/http/main.go
+++ b/cmd/http/main.go
@@ -43,7 +43,6 @@ func main() {
 	var err error
 	var gettextDir string
 	var langs args.LangVar
-	var logDbConnStr string

 	flag.StringVar(&override.DbConn, "c", "?", "default connection string (replaces all unspecified strings)")
 	flag.StringVar(&override.UserConn, "userdata", "?", "userdata store connection string")
@@ -56,7 +55,6 @@ func main() {
 	flag.UintVar(&port, "p", config.Port(), "http port")
 	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
 	flag.Var(&langs, "language", "add symbol resolution for language")
-	flag.StringVar(&logDbConnStr, "log-c", "db-logs", "log db connection string")
 	flag.Parse()

 	config.Apply(override)
@@ -105,12 +103,6 @@ func main() {
 		os.Exit(1)
 	}

-	logdb, err := menuStorageService.GetLogDb(ctx, userdataStore, logDbConnStr, "user-data")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "get log db error: %v\n", err)
-		os.Exit(1)
-	}
-
 	dbResource, ok := rs.(*resource.DbResource)
 	if !ok {
 		os.Exit(1)
@@ -118,7 +110,6 @@ func main() {

 	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
 	lhs.SetDataStore(&userdataStore)
-	lhs.SetLogDb(&logdb)

 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -36,7 +36,6 @@ func main() {
 	var err error
 	var gettextDir string
 	var langs args.LangVar
-	var logDbConnStr string

 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&override.DbConn, "c", "?", "default connection string (replaces all unspecified strings)")
@@ -47,7 +46,6 @@ func main() {
 	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.StringVar(&gettextDir, "gettext", "", "use gettext translations from given directory")
 	flag.Var(&langs, "language", "add symbol resolution for language")
-	flag.StringVar(&logDbConnStr, "log-c", "db-logs", "log db connection string")
 	flag.Parse()

 	config.Apply(override)
@@ -112,12 +110,6 @@ func main() {
 		os.Exit(1)
 	}

-	logdb, err := menuStorageService.GetLogDb(ctx, userdatastore, logDbConnStr, "user-data")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "get log db error: %v\n", err)
-		os.Exit(1)
-	}
-
 	dbResource, ok := rs.(*resource.DbResource)
 	if !ok {
 		fmt.Fprintf(os.Stderr, "get dbresource error: %v\n", err)
@@ -126,7 +118,6 @@ func main() {

 	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
 	lhs.SetDataStore(&userdatastore)
-	lhs.SetLogDb(&logdb)
 	lhs.SetPersister(pe)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "localhandler service error: %v\n", err)
--- a/devtools/admin/main.go
+++ b/devtools/admin/main.go
@@ -8,6 +8,7 @@ import (
 	"path"

 	"git.defalsify.org/vise.git/logging"
+	"git.defalsify.org/vise.git/engine"

 	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/handlers/application"
@@ -18,6 +19,7 @@ import (
 var (
 	logg      = logging.NewVanilla().WithContextKey("SessionId")
 	scriptDir = path.Join("services", "registration")
+	menuSeparator = ": "
 )

 func main() {
@@ -25,6 +27,8 @@ func main() {

 	override := config.NewOverride()
 	var sessionId string
+	var size uint
+	var engineDebug bool

 	flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
 	flag.StringVar(&override.DbConn, "c", "?", "default connection string (replaces all unspecified strings)")
@@ -32,6 +36,8 @@ func main() {

 	flag.StringVar(&override.UserConn, "userdata", "?", "userdata store connection string")
 	flag.StringVar(&override.StateConn, "state", "?", "state store connection string")
+	flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
+	flag.UintVar(&size, "s", 160, "max size of output")
 	flag.Parse()

 	config.Apply(override)
@@ -50,7 +56,18 @@ func main() {
 		os.Exit(1)
 	}

+	cfg := engine.Config{
+		Root:              "root",
+		SessionId:         sessionId,
+		OutputSize:        uint32(size),
+		FlagCount:         uint32(128),
+		MenuSeparator:     menuSeparator,
+		EngineDebug:       engineDebug,
+		ResetOnEmptyInput: true,
+	}
+
 	x := cmd.NewCmd(sessionId, flagParser)
+	x = x.WithEngine(cfg)
 	err = x.Parse(flag.Args())
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "cmd parse fail: %v\n", err)
--- a/go.mod
+++ b/go.mod
@@ -3,10 +3,10 @@ module git.grassecon.net/grassrootseconomics/sarafu-vise
 go 1.23.4

 require (
-	git.defalsify.org/vise.git v0.3.2-0.20250425131748-8b84f59792ce
-	git.grassecon.net/grassrootseconomics/common v0.9.0-beta.1.0.20250417111317-2953f4c2f32e
-	git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250428082711-5d221b8d565f
-	git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2.0.20250408094335-e2d1f65bb306
+	git.defalsify.org/vise.git v0.3.2-0.20250326034808-b9c2294cbf1a
+	git.grassecon.net/grassrootseconomics/common v0.0.0-20250121134736-ba8cbbccea7d
+	git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250310093912-8145b4bd004b
+	git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2
 	git.grassecon.net/grassrootseconomics/visedriver-africastalking v0.0.0-20250129070628-5a539172c694
 	github.com/alecthomas/assert/v2 v2.2.2
 	github.com/gofrs/uuid v4.4.0+incompatible
--- a/go.sum
+++ b/go.sum
@@ -1,11 +1,11 @@
-git.defalsify.org/vise.git v0.3.2-0.20250425131748-8b84f59792ce h1:Uke2jQ4wG97gQKnTzxPyBGyhosrU1IWnRNFHtKVrmrk=
-git.defalsify.org/vise.git v0.3.2-0.20250425131748-8b84f59792ce/go.mod h1:jyBMe1qTYUz3mmuoC9JQ/TvFeW0vTanCUcPu3H8p4Ck=
-git.grassecon.net/grassrootseconomics/common v0.9.0-beta.1.0.20250417111317-2953f4c2f32e h1:DcC9qkNl9ny3hxQmsMK6W81+5R/j4ZwYUbvewMI/rlc=
-git.grassecon.net/grassrootseconomics/common v0.9.0-beta.1.0.20250417111317-2953f4c2f32e/go.mod h1:wgQJZGIS6QuNLHqDhcsvehsbn5PvgV7aziRebMnJi60=
-git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250428082711-5d221b8d565f h1:OAHCP3YR1C5h1WFnnEnLs5kn6jTxQHQYWYtQaMZJIMY=
-git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250428082711-5d221b8d565f/go.mod h1:gOn89ipaDcDvmQXRMQYKUqcw/sJcwVOPVt2eC6Geip8=
-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.defalsify.org/vise.git v0.3.2-0.20250326034808-b9c2294cbf1a h1:5uLBUZC6armYgBPkuNEsQPtqT3qZxRfNP4HUdkhjm4I=
+git.defalsify.org/vise.git v0.3.2-0.20250326034808-b9c2294cbf1a/go.mod h1:jyBMe1qTYUz3mmuoC9JQ/TvFeW0vTanCUcPu3H8p4Ck=
+git.grassecon.net/grassrootseconomics/common v0.0.0-20250121134736-ba8cbbccea7d h1:5mzLas+jxTUtusOKx4XvU+n2QvrV/mH17MnJRy46siQ=
+git.grassecon.net/grassrootseconomics/common v0.0.0-20250121134736-ba8cbbccea7d/go.mod h1:wgQJZGIS6QuNLHqDhcsvehsbn5PvgV7aziRebMnJi60=
+git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250310093912-8145b4bd004b h1:xiTpaqWWoF5qcnarY/9ZkT6aVdnKwqztb2gzIahJn4w=
+git.grassecon.net/grassrootseconomics/sarafu-api v0.9.0-beta.1.0.20250310093912-8145b4bd004b/go.mod h1:gOn89ipaDcDvmQXRMQYKUqcw/sJcwVOPVt2eC6Geip8=
+git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2 h1:YFztSsexCUgFo6M0tbngRwYdgJd3LQV3RO/Jw09u3+k=
+git.grassecon.net/grassrootseconomics/visedriver v0.9.0-beta.2/go.mod h1:6B6ByxXOiRY0NR7K02Bf3fEu7z+2c/6q8PFVNjC5G8w=
 git.grassecon.net/grassrootseconomics/visedriver-africastalking v0.0.0-20250129070628-5a539172c694 h1:DjJlBSz0S13acft5XZDWk7ZYnzElym0xLMYEVgyNJ+E=
 git.grassecon.net/grassrootseconomics/visedriver-africastalking v0.0.0-20250129070628-5a539172c694/go.mod h1:DpibtYpnT3nG4Kn556hRAkdu4+CtiI/6MbnQHal51mQ=
 github.com/alecthomas/assert/v2 v2.2.2 h1:Z/iVC0xZfWTaFNE6bA3z07T86hd45Xe2eLt6WVy2bbk=
--- a/handlers/application/menuhandler.go
+++ b/handlers/application/menuhandler.go
@@ -29,7 +29,6 @@ import (
 	"git.grassecon.net/grassrootseconomics/sarafu-api/models"
 	"git.grassecon.net/grassrootseconomics/sarafu-api/remote"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/config"
-	"git.grassecon.net/grassrootseconomics/sarafu-vise/internal/sms"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/profile"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
 	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
@@ -78,28 +77,18 @@ type MenuHandlers struct {
 	flagManager          *FlagManager
 	accountService       remote.AccountService
 	prefixDb             storedb.PrefixDb
-	smsService           sms.SmsService
-	logDb                store.LogDb
 	profile              *profile.Profile
 	ReplaceSeparatorFunc func(string) string
 }

 // NewHandlers creates a new instance of the Handlers struct with the provided dependencies.
-func NewMenuHandlers(appFlags *FlagManager, userdataStore db.Db, logdb db.Db, accountService remote.AccountService, replaceSeparatorFunc func(string) string) (*MenuHandlers, error) {
+func NewMenuHandlers(appFlags *FlagManager, userdataStore db.Db, accountService remote.AccountService, replaceSeparatorFunc func(string) string) (*MenuHandlers, error) {
 	if userdataStore == nil {
 		return nil, fmt.Errorf("cannot create handler with nil userdata store")
 	}
 	userDb := &store.UserDataStore{
 		Db: userdataStore,
 	}
-	smsservice := sms.SmsService{
-		Accountservice: accountService,
-		Userdatastore:  *userDb,
-	}
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	// Instantiate the SubPrefixDb with "DATATYPE_USERDATA" prefix
 	prefix := storedb.ToBytes(db.DATATYPE_USERDATA)
@@ -109,9 +98,7 @@ func NewMenuHandlers(appFlags *FlagManager, userdataStore db.Db, logdb db.Db, ac
 		userdataStore:        userDb,
 		flagManager:          appFlags,
 		accountService:       accountService,
-		smsService:           smsservice,
 		prefixDb:             prefixDb,
-		logDb:                logDb,
 		profile:              &profile.Profile{Max: 6},
 		ReplaceSeparatorFunc: replaceSeparatorFunc,
 	}
@@ -212,16 +199,11 @@ func (h *MenuHandlers) createAccountNoExist(ctx context.Context, sessionId strin
 		storedb.DATA_ACCOUNT_ALIAS: "",
 	}
 	store := h.userdataStore
-	logdb := h.logDb
 	for key, value := range data {
 		err = store.WriteEntry(ctx, sessionId, key, []byte(value))
 		if err != nil {
 			return err
 		}
-		err = logdb.WriteLogEntry(ctx, sessionId, key, []byte(value))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write log entry", "key", key, "value", value)
-		}
 	}
 	publicKeyNormalized, err := hex.NormalizeHex(publicKey)
 	if err != nil {
@@ -231,12 +213,6 @@ func (h *MenuHandlers) createAccountNoExist(ctx context.Context, sessionId strin
 	if err != nil {
 		return err
 	}
-
-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY_REVERSE, []byte(sessionId))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write log entry", "key", storedb.DATA_PUBLIC_KEY_REVERSE, "value", sessionId)
-	}
-
 	res.FlagSet = append(res.FlagSet, flag_account_created)
 	return nil
 }
@@ -269,7 +245,6 @@ func (h *MenuHandlers) CreateAccount(ctx context.Context, sym string, input []by

 func (h *MenuHandlers) CheckAccountCreated(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-	flag_language_set, _ := h.flagManager.GetFlag("flag_language_set")
 	flag_account_created, _ := h.flagManager.GetFlag("flag_account_created")

 	store := h.userdataStore
@@ -281,46 +256,35 @@ func (h *MenuHandlers) CheckAccountCreated(ctx context.Context, sym string, inpu

 	_, err := store.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
 	if err != nil {
-		if db.IsNotFound(err) {
-			// reset major flags
-			res.FlagReset = append(res.FlagReset, flag_language_set)
-			res.FlagReset = append(res.FlagReset, flag_account_created)
-
-			return res, nil
+		if !db.IsNotFound(err) {
+			return res, err
 		}
-
 		return res, nil
 	}
-
 	res.FlagSet = append(res.FlagSet, flag_account_created)
 	return res, nil
 }

-// CheckBlockedStatus:
-// 1. Checks whether the DATA_SELF_PIN_RESET is 1 and sets the flag_account_pin_reset
-// 2. resets the account blocked flag if the PIN attempts have been reset by an admin.
+// ResetValidPin resets the flag_valid_pin flag.
+func (h *MenuHandlers) ResetValidPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+	var res resource.Result
+	flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
+	res.FlagReset = append(res.FlagReset, flag_valid_pin)
+	return res, nil
+}
+
+// CheckBlockedStatus resets the account blocked flag if the PIN attempts have been reset by an admin.
 func (h *MenuHandlers) CheckBlockedStatus(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	store := h.userdataStore

 	flag_account_blocked, _ := h.flagManager.GetFlag("flag_account_blocked")
-	flag_account_pin_reset, _ := h.flagManager.GetFlag("flag_account_pin_reset")

 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}

-	res.FlagReset = append(res.FlagReset, flag_account_pin_reset)
-
-	selfPinReset, err := store.ReadEntry(ctx, sessionId, storedb.DATA_SELF_PIN_RESET)
-	if err == nil {
-		pinResetValue, _ := strconv.ParseUint(string(selfPinReset), 0, 64)
-		if pinResetValue == 1 {
-			res.FlagSet = append(res.FlagSet, flag_account_pin_reset)
-		}
-	}
-
 	currentWrongPinAttempts, err := store.ReadEntry(ctx, sessionId, storedb.DATA_INCORRECT_PIN_ATTEMPTS)
 	if err != nil {
 		if !db.IsNotFound(err) {
@@ -329,6 +293,7 @@ func (h *MenuHandlers) CheckBlockedStatus(ctx context.Context, sym string, input
 	}

 	pinAttemptsValue, _ := strconv.ParseUint(string(currentWrongPinAttempts), 0, 64)
+
 	if pinAttemptsValue == 0 {
 		res.FlagReset = append(res.FlagReset, flag_account_blocked)
 		return res, nil
@@ -371,6 +336,29 @@ func (h *MenuHandlers) ResetIncorrectPin(ctx context.Context, sym string, input
 	return res, nil
 }

+// VerifyNewPin checks if a new PIN meets the required format criteria.
+func (h *MenuHandlers) VerifyNewPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+	res := resource.Result{}
+	_, ok := ctx.Value("SessionId").(string)
+	if !ok {
+		return res, fmt.Errorf("missing session")
+	}
+	flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
+	if string(input) != "0" {
+		pinInput := string(input)
+		// Validate that the PIN is a 4-digit number.
+		if pin.IsValidPIN(pinInput) {
+			res.FlagSet = append(res.FlagSet, flag_valid_pin)
+		} else {
+			res.FlagReset = append(res.FlagReset, flag_valid_pin)
+		}
+	} else {
+		res.FlagSet = append(res.FlagSet, flag_valid_pin)
+	}
+
+	return res, nil
+}
+
 // SaveTemporaryPin saves the valid PIN input to the DATA_TEMPORARY_VALUE,
 // during the account creation process
 // and during the change PIN process.
@@ -383,20 +371,15 @@ func (h *MenuHandlers) SaveTemporaryPin(ctx context.Context, sym string, input [
 		return res, fmt.Errorf("missing session")
 	}

-	flag_invalid_pin, _ := h.flagManager.GetFlag("flag_invalid_pin")
-
-	if string(input) == "0" {
-		return res, nil
-	}
-
+	flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
 	accountPIN := string(input)

-	// Validate that the PIN has a valid format.
+	// Validate that the PIN is a 4-digit number.
 	if !pin.IsValidPIN(accountPIN) {
-		res.FlagSet = append(res.FlagSet, flag_invalid_pin)
+		res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
 		return res, nil
 	}
-	res.FlagReset = append(res.FlagReset, flag_invalid_pin)
+	res.FlagReset = append(res.FlagReset, flag_incorrect_pin)

 	// Hash the PIN
 	hashedPIN, err := pin.HashPIN(string(accountPIN))
@@ -406,19 +389,93 @@ func (h *MenuHandlers) SaveTemporaryPin(ctx context.Context, sym string, input [
 	}

 	store := h.userdataStore
-	logdb := h.logDb
-
 	err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to write temporaryAccountPIN entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", accountPIN, "error", err)
 		return res, err
 	}

-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write temporaryAccountPIN log entry", "key", storedb.DATA_TEMPORARY_VALUE, "value", accountPIN, "error", err)
+	return res, nil
+}
+
+// SaveOthersTemporaryPin allows authorized users to set temporary PINs for blocked numbers.
+func (h *MenuHandlers) SaveOthersTemporaryPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+	var res resource.Result
+	var err error
+
+	store := h.userdataStore
+	sessionId, ok := ctx.Value("SessionId").(string)
+	if !ok {
+		return res, fmt.Errorf("missing session")
 	}

+	temporaryPin := string(input)
+
+	// Validate that the input is a 4-digit number.
+	if !pin.IsValidPIN(temporaryPin) {
+		return res, nil
+	}
+
+	// Retrieve the blocked number associated with this session
+	blockedNumber, err := store.ReadEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read blockedNumber entry with", "key", storedb.DATA_BLOCKED_NUMBER, "error", err)
+		return res, err
+	}
+
+	// Hash the temporary PIN
+	hashedPIN, err := pin.HashPIN(string(temporaryPin))
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to hash temporaryPin", "error", err)
+		return res, err
+	}
+
+	// Save the hashed temporary PIN for that blocked number
+	err = store.WriteEntry(ctx, string(blockedNumber), storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to write hashed temporaryPin entry with", "key", storedb.DATA_TEMPORARY_VALUE, "value", temporaryPin, "error", err)
+		return res, err
+	}
+
+	return res, nil
+}
+
+// CheckBlockedNumPinMisMatch checks if the provided PIN matches a temporary PIN stored for a blocked number.
+func (h *MenuHandlers) CheckBlockedNumPinMisMatch(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+	res := resource.Result{}
+	flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
+	sessionId, ok := ctx.Value("SessionId").(string)
+	if !ok {
+		return res, fmt.Errorf("missing session")
+	}
+	if string(input) == "0" {
+		res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
+		return res, nil
+	}
+
+	// Get blocked number from storage.
+	store := h.userdataStore
+	blockedNumber, err := store.ReadEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read blockedNumber entry with", "key", storedb.DATA_BLOCKED_NUMBER, "error", err)
+		return res, err
+	}
+	// Get Hashed temporary PIN for the blocked number.
+	hashedTemporaryPin, err := store.ReadEntry(ctx, string(blockedNumber), storedb.DATA_TEMPORARY_VALUE)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read hashedTemporaryPin entry with", "key", storedb.DATA_TEMPORARY_VALUE, "error", err)
+		return res, err
+	}
+	if len(hashedTemporaryPin) == 0 {
+		logg.ErrorCtxf(ctx, "hashedTemporaryPin is empty", "key", storedb.DATA_TEMPORARY_VALUE)
+		return res, fmt.Errorf("Data error encountered")
+	}
+
+	if pin.VerifyPIN(string(hashedTemporaryPin), string(input)) {
+		res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
+	} else {
+		res.FlagSet = append(res.FlagSet, flag_pin_mismatch)
+	}
 	return res, nil
 }

@@ -438,7 +495,6 @@ func (h *MenuHandlers) ConfirmPinChange(ctx context.Context, sym string, input [
 		return res, fmt.Errorf("missing session")
 	}
 	flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
-	flag_account_pin_reset, _ := h.flagManager.GetFlag("flag_account_pin_reset")

 	if string(input) == "0" {
 		res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
@@ -446,7 +502,6 @@ func (h *MenuHandlers) ConfirmPinChange(ctx context.Context, sym string, input [
 	}

 	store := h.userdataStore
-	logdb := h.logDb
 	hashedTemporaryPin, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to read hashedTemporaryPin entry with", "key", storedb.DATA_TEMPORARY_VALUE, "error", err)
@@ -471,85 +526,16 @@ func (h *MenuHandlers) ConfirmPinChange(ctx context.Context, sym string, input [
 		return res, err
 	}

-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_ACCOUNT_PIN, []byte(hashedTemporaryPin))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write AccountPIN log entry", "key", storedb.DATA_ACCOUNT_PIN, "value", hashedTemporaryPin, "error", err)
-	}
-
-	// set the DATA_SELF_PIN_RESET as 0
-	err = store.WriteEntry(ctx, sessionId, storedb.DATA_SELF_PIN_RESET, []byte("0"))
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to write DATA_SELF_PIN_RESET entry with", "key", storedb.DATA_SELF_PIN_RESET, "self PIN reset value", "0", "error", err)
-		return res, err
-	}
-	res.FlagReset = append(res.FlagReset, flag_account_pin_reset)
-
-	return res, nil
-}
-
-// ValidateBlockedNumber performs validation of phone numbers during the Reset other's PIN.
-// It checks phone number format and verifies registration status.
-// If valid, it writes the number under DATA_BLOCKED_NUMBER on the admin account
-func (h *MenuHandlers) ValidateBlockedNumber(ctx context.Context, sym string, input []byte) (resource.Result, error) {
-	var res resource.Result
-	var err error
-
-	flag_unregistered_number, _ := h.flagManager.GetFlag("flag_unregistered_number")
-	store := h.userdataStore
-	logdb := h.logDb
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return res, fmt.Errorf("missing session")
-	}
-
-	if string(input) == "0" {
-		res.FlagReset = append(res.FlagReset, flag_unregistered_number)
-		return res, nil
-	}
-
-	blockedNumber := string(input)
-	formattedNumber, err := phone.FormatPhoneNumber(blockedNumber)
-	if err != nil {
-		res.FlagSet = append(res.FlagSet, flag_unregistered_number)
-		logg.ErrorCtxf(ctx, "Failed to format the phone number: %s", blockedNumber, "error", err)
-		return res, nil
-	}
-
-	_, err = store.ReadEntry(ctx, formattedNumber, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		if db.IsNotFound(err) {
-			logg.InfoCtxf(ctx, "Invalid or unregistered number")
-			res.FlagSet = append(res.FlagSet, flag_unregistered_number)
-			return res, nil
-		} else {
-			logg.ErrorCtxf(ctx, "Error on ValidateBlockedNumber", "error", err)
-			return res, err
-		}
-	}
-
-	err = store.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(formattedNumber))
-	if err != nil {
-		return res, nil
-	}
-
-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(formattedNumber))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write blocked number log entry", "key", storedb.DATA_BLOCKED_NUMBER, "value", formattedNumber, "error", err)
-	}
-
 	return res, nil
 }

 // ResetOthersPin handles the PIN reset process for other users' accounts by:
 // 1. Retrieving the blocked phone number from the session
-// 2. Writing the DATA_SELF_PIN_RESET on the blocked phone number
-// 3. Resetting the DATA_INCORRECT_PIN_ATTEMPTS to 0 for the blocked phone number
+// 2. Fetching the hashed temporary PIN associated with that number
+// 3. Updating the account PIN with the temporary PIN
 func (h *MenuHandlers) ResetOthersPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-
 	store := h.userdataStore
-	smsservice := h.smsService
-
 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
 		return res, fmt.Errorf("missing session")
@@ -559,11 +545,19 @@ func (h *MenuHandlers) ResetOthersPin(ctx context.Context, sym string, input []b
 		logg.ErrorCtxf(ctx, "failed to read blockedPhonenumber entry with", "key", storedb.DATA_BLOCKED_NUMBER, "error", err)
 		return res, err
 	}
-
-	// set the DATA_SELF_PIN_RESET for the account
-	err = store.WriteEntry(ctx, string(blockedPhonenumber), storedb.DATA_SELF_PIN_RESET, []byte("1"))
+	hashedTemporaryPin, err := store.ReadEntry(ctx, string(blockedPhonenumber), storedb.DATA_TEMPORARY_VALUE)
 	if err != nil {
-		return res, nil
+		logg.ErrorCtxf(ctx, "failed to read hashedTmporaryPin entry with", "key", storedb.DATA_TEMPORARY_VALUE, "error", err)
+		return res, err
+	}
+	if len(hashedTemporaryPin) == 0 {
+		logg.ErrorCtxf(ctx, "hashedTemporaryPin is empty", "key", storedb.DATA_TEMPORARY_VALUE)
+		return res, fmt.Errorf("Data error encountered")
+	}
+
+	err = store.WriteEntry(ctx, string(blockedPhonenumber), storedb.DATA_ACCOUNT_PIN, []byte(hashedTemporaryPin))
+	if err != nil {
+		return res, err
 	}

 	err = store.WriteEntry(ctx, string(blockedPhonenumber), storedb.DATA_INCORRECT_PIN_ATTEMPTS, []byte(string("0")))
@@ -571,15 +565,7 @@ func (h *MenuHandlers) ResetOthersPin(ctx context.Context, sym string, input []b
 		logg.ErrorCtxf(ctx, "failed to reset incorrect PIN attempts", "key", storedb.DATA_INCORRECT_PIN_ATTEMPTS, "error", err)
 		return res, err
 	}
-	blockedPhoneStr := string(blockedPhonenumber)
-	//Trigger an SMS to inform a user that the  blocked account has been reset
-	if phone.IsValidPhoneNumber(blockedPhoneStr) {
-		err = smsservice.SendPINResetSMS(ctx, sessionId, blockedPhoneStr)
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to send PIN reset SMS", "error", err)
-			return res, nil
-		}
-	}
+
 	return res, nil
 }

@@ -642,29 +628,65 @@ func (h *MenuHandlers) ResetUnregisteredNumber(ctx context.Context, sym string,
 	return res, nil
 }

+// ValidateBlockedNumber performs validation of phone numbers, specifically for blocked numbers in the system.
+// It checks phone number format and verifies registration status.
+func (h *MenuHandlers) ValidateBlockedNumber(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+	var res resource.Result
+	var err error
+
+	flag_unregistered_number, _ := h.flagManager.GetFlag("flag_unregistered_number")
+	store := h.userdataStore
+	sessionId, ok := ctx.Value("SessionId").(string)
+	if !ok {
+		return res, fmt.Errorf("missing session")
+	}
+
+	if string(input) == "0" {
+		res.FlagReset = append(res.FlagReset, flag_unregistered_number)
+		return res, nil
+	}
+
+	blockedNumber := string(input)
+	formattedNumber, err := phone.FormatPhoneNumber(blockedNumber)
+	if err != nil {
+		res.FlagSet = append(res.FlagSet, flag_unregistered_number)
+		logg.ErrorCtxf(ctx, "Failed to format the phone number: %s", blockedNumber, "error", err)
+		return res, nil
+	}
+
+	_, err = store.ReadEntry(ctx, formattedNumber, storedb.DATA_PUBLIC_KEY)
+	if err != nil {
+		if db.IsNotFound(err) {
+			logg.InfoCtxf(ctx, "Invalid or unregistered number")
+			res.FlagSet = append(res.FlagSet, flag_unregistered_number)
+			return res, nil
+		} else {
+			logg.ErrorCtxf(ctx, "Error on ValidateBlockedNumber", "error", err)
+			return res, err
+		}
+	}
+	err = store.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(formattedNumber))
+	if err != nil {
+		return res, nil
+	}
+	return res, nil
+}
+
 // VerifyCreatePin checks whether the confirmation PIN is similar to the temporary PIN
 // If similar, it sets the USERFLAG_PIN_SET flag and writes the account PIN allowing the user
 // to access the main menu.
 func (h *MenuHandlers) VerifyCreatePin(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_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
 	flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
 	flag_pin_set, _ := h.flagManager.GetFlag("flag_pin_set")

-	if string(input) == "0" {
-		res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
-		return res, nil
+	sessionId, ok := ctx.Value("SessionId").(string)
+	if !ok {
+		return res, fmt.Errorf("missing session")
 	}
-
 	store := h.userdataStore
-	logdb := h.logDb
-
 	hashedTemporaryPin, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to read hashedTemporaryPin entry with", "key", storedb.DATA_TEMPORARY_VALUE, "error", err)
@@ -676,26 +698,20 @@ func (h *MenuHandlers) VerifyCreatePin(ctx context.Context, sym string, input []
 	}

 	if pin.VerifyPIN(string(hashedTemporaryPin), string(input)) {
-		res.FlagSet = append(res.FlagSet, flag_valid_pin)
+		res.FlagSet = []uint32{flag_valid_pin}
+		res.FlagReset = []uint32{flag_pin_mismatch}
 		res.FlagSet = append(res.FlagSet, flag_pin_set)
-		res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
 	} else {
-		res.FlagSet = append(res.FlagSet, flag_pin_mismatch)
+		res.FlagSet = []uint32{flag_pin_mismatch}
 		return res, nil
 	}

-	// save the hashed PIN as the new account PIN
 	err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACCOUNT_PIN, []byte(hashedTemporaryPin))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to write DATA_ACCOUNT_PIN entry with", "key", storedb.DATA_ACCOUNT_PIN, "value", hashedTemporaryPin, "error", err)
 		return res, err
 	}

-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_ACCOUNT_PIN, []byte(hashedTemporaryPin))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write DATA_ACCOUNT_PIN log entry", "key", storedb.DATA_ACCOUNT_PIN, "value", hashedTemporaryPin, "error", err)
-	}
-
 	return res, nil
 }

@@ -708,10 +724,7 @@ func (h *MenuHandlers) SaveFirstname(ctx context.Context, sym string, input []by
 		return res, fmt.Errorf("missing session")
 	}
 	firstName := string(input)
-
 	store := h.userdataStore
-	logdb := h.logDb
-
 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
 	flag_firstname_set, _ := h.flagManager.GetFlag("flag_firstname_set")

@@ -729,11 +742,6 @@ func (h *MenuHandlers) SaveFirstname(ctx context.Context, sym string, input []by
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_firstname_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_FIRST_NAME, []byte(temporaryFirstName))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write firtname db log entry", "key", storedb.DATA_FIRST_NAME, "value", temporaryFirstName)
-		}
 	} else {
 		if firstNameSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(firstName))
@@ -759,7 +767,6 @@ func (h *MenuHandlers) SaveFamilyname(ctx context.Context, sym string, input []b
 	}

 	store := h.userdataStore
-	logdb := h.logDb
 	familyName := string(input)

 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
@@ -779,11 +786,6 @@ func (h *MenuHandlers) SaveFamilyname(ctx context.Context, sym string, input []b
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_familyname_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_FAMILY_NAME, []byte(temporaryFamilyName))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write firtname db log entry", "key", storedb.DATA_FAMILY_NAME, "value", temporaryFamilyName)
-		}
 	} else {
 		if familyNameSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(familyName))
@@ -840,8 +842,6 @@ func (h *MenuHandlers) SaveYob(ctx context.Context, sym string, input []byte) (r
 	}
 	yob := string(input)
 	store := h.userdataStore
-	logdb := h.logDb
-
 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
 	flag_yob_set, _ := h.flagManager.GetFlag("flag_yob_set")

@@ -860,11 +860,6 @@ func (h *MenuHandlers) SaveYob(ctx context.Context, sym string, input []byte) (r
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_yob_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_YOB, []byte(temporaryYob))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write yob db log entry", "key", storedb.DATA_YOB, "value", temporaryYob)
-		}
 	} else {
 		if yobSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(yob))
@@ -890,7 +885,6 @@ func (h *MenuHandlers) SaveLocation(ctx context.Context, sym string, input []byt
 	}
 	location := string(input)
 	store := h.userdataStore
-	logdb := h.logDb

 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
 	flag_location_set, _ := h.flagManager.GetFlag("flag_location_set")
@@ -909,11 +903,6 @@ func (h *MenuHandlers) SaveLocation(ctx context.Context, sym string, input []byt
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_location_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_LOCATION, []byte(temporaryLocation))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write location db log entry", "key", storedb.DATA_LOCATION, "value", temporaryLocation)
-		}
 	} else {
 		if locationSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(location))
@@ -941,7 +930,6 @@ func (h *MenuHandlers) SaveGender(ctx context.Context, sym string, input []byte)
 	}
 	gender := strings.Split(symbol, "_")[1]
 	store := h.userdataStore
-	logdb := h.logDb
 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
 	flag_gender_set, _ := h.flagManager.GetFlag("flag_gender_set")

@@ -960,12 +948,6 @@ func (h *MenuHandlers) SaveGender(ctx context.Context, sym string, input []byte)
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_gender_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_GENDER, []byte(temporaryGender))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write gender db log entry", "key", storedb.DATA_TEMPORARY_VALUE, "value", temporaryGender)
-		}
-
 	} else {
 		if genderSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(gender))
@@ -992,7 +974,6 @@ func (h *MenuHandlers) SaveOfferings(ctx context.Context, sym string, input []by

 	offerings := string(input)
 	store := h.userdataStore
-	logdb := h.logDb

 	flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")
 	flag_offerings_set, _ := h.flagManager.GetFlag("flag_offerings_set")
@@ -1012,11 +993,6 @@ func (h *MenuHandlers) SaveOfferings(ctx context.Context, sym string, input []by
 			return res, err
 		}
 		res.FlagSet = append(res.FlagSet, flag_offerings_set)
-
-		err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_FIRST_NAME, []byte(temporaryOfferings))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write offerings db log entry", "key", storedb.DATA_OFFERINGS, "value", offerings)
-		}
 	} else {
 		if offeringsSet {
 			err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(offerings))
@@ -1316,30 +1292,17 @@ func (h *MenuHandlers) ResetAccountAuthorized(ctx context.Context, sym string, i
 	return res, nil
 }

-// CheckIdentifier retrieves the Public key from the userdatastore under the key: DATA_PUBLIC_KEY and triggers an sms that
-// will be sent to the associated session id
+// CheckIdentifier retrieves the PublicKey from the JSON data file.
 func (h *MenuHandlers) CheckIdentifier(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
-
-	smsservice := h.smsService
-
 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}
 	store := h.userdataStore
-	publicKey, err := store.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
-		return res, err
-	}
+	publicKey, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
+
 	res.Content = string(publicKey)
-	//trigger an address sms to be delivered to the associated session id
-	err = smsservice.SendAddressSMS(ctx)
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to trigger an address sms", "error", err)
-		return res, nil
-	}

 	return res, nil
 }
@@ -1736,7 +1699,6 @@ func (h *MenuHandlers) TransactionReset(ctx context.Context, sym string, input [
 func (h *MenuHandlers) InviteValidRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	store := h.userdataStore
-	smsservice := h.smsService

 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
@@ -1747,23 +1709,18 @@ func (h *MenuHandlers) InviteValidRecipient(ctx context.Context, sym string, inp
 	l := gotext.NewLocale(translationDir, code)
 	l.AddDomain("default")

-	recipient, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "Failed to read invalid recipient info", "error", err)
-		return res, err
+	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")
 	}

-	if !phone.IsValidPhoneNumber(string(recipient)) {
-		logg.InfoCtxf(ctx, "corrupted recipient", "key", storedb.DATA_TEMPORARY_VALUE, "recipient", recipient)
-		return res, nil
-	}
+	// TODO
+	// send an invitation SMS
+	// if successful
+	// res.Content = l.Get("Your invitation to %s to join Sarafu Network has been sent.",  string(recipient))

-	_, err = smsservice.Accountservice.SendUpsellSMS(ctx, sessionId, string(recipient))
-	if err != nil {
-		res.Content = l.Get("Your invite request for %s to Sarafu Network failed. Please try again later.", string(recipient))
-		return res, nil
-	}
-	res.Content = l.Get("Your invitation to %s to join Sarafu Network has been sent.", string(recipient))
+	res.Content = l.Get("Your invite request for %s to Sarafu Network failed. Please try again later.", string(recipient))
 	return res, nil
 }

@@ -1989,14 +1946,11 @@ func (h *MenuHandlers) InitiateTransaction(ctx context.Context, sym string, inpu
 	return res, nil
 }

-// 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
-func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []byte) (resource.Result, error) {
+// SetDefaultVoucher retrieves the current vouchers
+// and sets the first as the default voucher, if no active voucher is set.
+func (h *MenuHandlers) SetDefaultVoucher(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	userStore := h.userdataStore
-	logdb := h.logDb

 	sessionId, ok := ctx.Value("SessionId").(string)
 	if !ok {
@@ -2005,31 +1959,30 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b

 	flag_no_active_voucher, _ := h.flagManager.GetFlag("flag_no_active_voucher")

-	publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read publicKey entry", "key", storedb.DATA_PUBLIC_KEY, "error", err)
-		return res, err
-	}
-
-	// Fetch vouchers from API
-	vouchersResp, err := h.accountService.FetchVouchers(ctx, string(publicKey))
-	if err != nil {
-		res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
-		return res, nil
-	}
-
-	if len(vouchersResp) == 0 {
-		res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
-		return res, nil
-	}
-
-	res.FlagReset = append(res.FlagReset, flag_no_active_voucher)
-
-	// Check if user has an active voucher with proper error handling
-	activeSym, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
+	// check if the user has an active sym
+	_, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
 	if err != nil {
 		if db.IsNotFound(err) {
-			// No active voucher, set the first one as default
+			publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
+				return res, err
+			}
+
+			// Fetch vouchers from the API using the public key
+			vouchersResp, err := h.accountService.FetchVouchers(ctx, string(publicKey))
+			if err != nil {
+				res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
+				return res, nil
+			}
+
+			// Return if there is no voucher
+			if len(vouchersResp) == 0 {
+				res.FlagSet = append(res.FlagSet, flag_no_active_voucher)
+				return res, nil
+			}
+
+			// Use only the first voucher
 			firstVoucher := vouchersResp[0]
 			defaultSym := firstVoucher.TokenSymbol
 			defaultBal := firstVoucher.Balance
@@ -2039,31 +1992,71 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 			// Scale down the balance
 			scaledBalance := store.ScaleDownBalance(defaultBal, defaultDec)

-			firstVoucherMap := map[storedb.DataTyp]string{
-				storedb.DATA_ACTIVE_SYM:     defaultSym,
-				storedb.DATA_ACTIVE_BAL:     scaledBalance,
-				storedb.DATA_ACTIVE_DECIMAL: defaultDec,
-				storedb.DATA_ACTIVE_ADDRESS: defaultAddr,
+			// TODO: implement atomic transaction
+			// set the active symbol
+			err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(defaultSym))
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write defaultSym entry with", "key", storedb.DATA_ACTIVE_SYM, "value", defaultSym, "error", err)
+				return res, err
+			}
+			// set the active balance
+			err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL, []byte(scaledBalance))
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write defaultBal entry with", "key", storedb.DATA_ACTIVE_BAL, "value", scaledBalance, "error", err)
+				return res, err
+			}
+			// set the active decimals
+			err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_DECIMAL, []byte(defaultDec))
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write defaultDec entry with", "key", storedb.DATA_ACTIVE_DECIMAL, "value", defaultDec, "error", err)
+				return res, err
+			}
+			// set the active contract address
+			err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte(defaultAddr))
+			if err != nil {
+				logg.ErrorCtxf(ctx, "failed to write defaultAddr entry with", "key", storedb.DATA_ACTIVE_ADDRESS, "value", defaultAddr, "error", err)
+				return res, err
 			}

-			for key, value := range firstVoucherMap {
-				if err := userStore.WriteEntry(ctx, sessionId, key, []byte(value)); err != nil {
-					logg.ErrorCtxf(ctx, "Failed to write active voucher data", "key", key, "error", err)
-					return res, err
-				}
-				err = logdb.WriteLogEntry(ctx, sessionId, key, []byte(value))
-				if err != nil {
-					logg.DebugCtxf(ctx, "Failed to write voucher db log entry", "key", key, "value", value)
-				}
-			}
-
-			logg.InfoCtxf(ctx, "Default voucher set", "symbol", defaultSym, "balance", defaultBal, "decimals", defaultDec, "address", defaultAddr)
-		} else {
-			logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
-			return res, err
+			return res, nil
 		}
-	} else {
-		// Update active voucher balance
+
+		logg.ErrorCtxf(ctx, "failed to read activeSym entry with", "key", storedb.DATA_ACTIVE_SYM, "error", err)
+		return res, err
+	}
+
+	res.FlagReset = append(res.FlagReset, flag_no_active_voucher)
+
+	return res, nil
+}
+
+// CheckVouchers retrieves the token holdings from the API using the "PublicKey" and stores
+// them to gdbm.
+func (h *MenuHandlers) CheckVouchers(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
+	publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
+		return res, err
+	}
+
+	// Fetch vouchers from the API using the public key
+	vouchersResp, err := h.accountService.FetchVouchers(ctx, string(publicKey))
+	if err != nil {
+		return res, nil
+	}
+
+	logg.InfoCtxf(ctx, "fetched user vouchers", "public_key", string(publicKey), "vouchers", vouchersResp)
+
+	// check the current active sym and update the data
+	activeSym, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM)
+	if activeSym != nil {
 		activeSymStr := string(activeSym)

 		// Find the matching voucher data
@@ -2093,8 +2086,14 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b
 		}
 	}

-	// Store all voucher data
+	activeBal, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_BAL)
+	activeAddr, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
+
+	logg.InfoCtxf(ctx, "The active data in CheckVouchers:", "activeSym", string(activeSym), string(activeBal), string(activeAddr))
+
 	data := store.ProcessVouchers(vouchersResp)
+
+	// Store all voucher data
 	dataMap := map[storedb.DataTyp]string{
 		storedb.DATA_VOUCHER_SYMBOLS:   data.Symbols,
 		storedb.DATA_VOUCHER_BALANCES:  data.Balances,
@@ -2104,6 +2103,7 @@ func (h *MenuHandlers) ManageVouchers(ctx context.Context, sym string, input []b

 	// Write data entries
 	for key, value := range dataMap {
+		logg.InfoCtxf(ctx, "Writing data entry for sessionId: %s", sessionId, "key", key, "value", value)
 		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
@@ -2251,7 +2251,6 @@ func (h *MenuHandlers) CheckTransactions(ctx context.Context, sym string, input
 	flag_api_error, _ := h.flagManager.GetFlag("flag_api_error")

 	userStore := h.userdataStore
-	logdb := h.logDb
 	publicKey, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
@@ -2291,10 +2290,6 @@ func (h *MenuHandlers) CheckTransactions(ctx context.Context, sym string, input
 			logg.ErrorCtxf(ctx, "failed to write to prefixDb", "error", err)
 			return res, err
 		}
-		err = logdb.WriteLogEntry(ctx, sessionId, key, []byte(value))
-		if err != nil {
-			logg.DebugCtxf(ctx, "Failed to write tx db log entry", "key", key, "value", value)
-		}
 	}

 	res.FlagReset = append(res.FlagReset, flag_no_transfers)
@@ -2533,10 +2528,9 @@ func (h *MenuHandlers) RequestCustomAlias(ctx context.Context, sym string, input
 			return res, fmt.Errorf("Failed to retrieve alias: %s", err.Error())
 		}
 		alias := aliasResult.Alias
-		logg.InfoCtxf(ctx, "Suggested alias ", "alias", alias)

 		//Store the returned alias,wait for user to confirm it as new account alias
-		err = store.WriteEntry(ctx, sessionId, storedb.DATA_SUGGESTED_ALIAS, []byte(alias))
+		err = store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(alias))
 		if err != nil {
 			logg.ErrorCtxf(ctx, "failed to write account alias", "key", storedb.DATA_TEMPORARY_VALUE, "value", alias, "error", err)
 			return res, err
@@ -2565,7 +2559,7 @@ func (h *MenuHandlers) GetSuggestedAlias(ctx context.Context, sym string, input
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}
-	suggestedAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_SUGGESTED_ALIAS)
+	suggestedAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
 	if err != nil {
 		return res, nil
 	}
@@ -2573,11 +2567,10 @@ func (h *MenuHandlers) GetSuggestedAlias(ctx context.Context, sym string, input
 	return res, nil
 }

-// ConfirmNewAlias  reads  the suggested alias from the [DATA_SUGGECTED_ALIAS] key and confirms it  as the new account alias.
+// ConfirmNewAlias  reads  the suggested alias from the temporary value and confirms it  as the new account alias.
 func (h *MenuHandlers) ConfirmNewAlias(ctx context.Context, sym string, input []byte) (resource.Result, error) {
 	var res resource.Result
 	store := h.userdataStore
-	logdb := h.logDb

 	flag_alias_set, _ := h.flagManager.GetFlag("flag_alias_set")

@@ -2585,22 +2578,16 @@ func (h *MenuHandlers) ConfirmNewAlias(ctx context.Context, sym string, input []
 	if !ok {
 		return res, fmt.Errorf("missing session")
 	}
-	newAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_SUGGESTED_ALIAS)
+	newAlias, err := store.ReadEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE)
 	if err != nil {
 		return res, nil
 	}
-	logg.InfoCtxf(ctx, "Confirming new alias", "alias", string(newAlias))
 	err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACCOUNT_ALIAS, []byte(string(newAlias)))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "failed to clear DATA_ACCOUNT_ALIAS_VALUE entry with", "key", storedb.DATA_ACCOUNT_ALIAS, "value", "empty", "error", err)
 		return res, err
 	}

-	err = logdb.WriteLogEntry(ctx, sessionId, storedb.DATA_ACCOUNT_ALIAS, []byte(newAlias))
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to write account alias db log entry", "key", storedb.DATA_ACCOUNT_ALIAS, "value", newAlias)
-	}
-
 	res.FlagSet = append(res.FlagSet, flag_alias_set)
 	return res, nil
 }
--- a/handlers/application/menuhandler_test.go
+++ b/handlers/application/menuhandler_test.go
@@ -62,25 +62,6 @@ func InitializeTestStore(t *testing.T) (context.Context, *store.UserDataStore) {
 	return ctx, store
 }

-// InitializeTestLogdbStore sets up and returns an in-memory database and logdb store.
-func InitializeTestLogdbStore(t *testing.T) (context.Context, *store.UserDataStore) {
-	ctx := context.Background()
-
-	// Initialize memDb
-	db := memdb.NewMemDb()
-	err := db.Connect(ctx, "")
-	require.NoError(t, err, "Failed to connect to memDb")
-
-	// Create UserDataStore with memDb
-	logdb := &store.UserDataStore{Db: db}
-
-	t.Cleanup(func() {
-		db.Close(ctx) // Ensure the DB is closed after each test
-	})
-
-	return ctx, logdb
-}
-
 func InitializeTestSubPrefixDb(t *testing.T, ctx context.Context) *storedb.SubPrefixDb {
 	db := memdb.NewMemDb()
 	err := db.Connect(ctx, "")
@@ -95,7 +76,6 @@ func InitializeTestSubPrefixDb(t *testing.T, ctx context.Context) *storedb.SubPr

 func TestNewMenuHandlers(t *testing.T) {
 	_, store := InitializeTestStore(t)
-	_, logdb := InitializeTestLogdbStore(t)

 	fm, err := NewFlagManager(flagsPath)
 	if err != nil {
@@ -106,7 +86,7 @@ func TestNewMenuHandlers(t *testing.T) {

 	// Test case for valid UserDataStore
 	t.Run("Valid UserDataStore", func(t *testing.T) {
-		handlers, err := NewMenuHandlers(fm, store, logdb, &accountService, mockReplaceSeparator)
+		handlers, err := NewMenuHandlers(fm, store, &accountService, mockReplaceSeparator)
 		if err != nil {
 			t.Fatalf("expected no error, got %v", err)
 		}
@@ -130,7 +110,7 @@ func TestNewMenuHandlers(t *testing.T) {

 	// Test case for nil UserDataStore
 	t.Run("Nil UserDataStore", func(t *testing.T) {
-		handlers, err := NewMenuHandlers(fm, nil, logdb, &accountService, mockReplaceSeparator)
+		handlers, err := NewMenuHandlers(fm, nil, &accountService, mockReplaceSeparator)
 		if err == nil {
 			t.Fatal("expected an error, got none")
 		}
@@ -212,13 +192,8 @@ func TestInit(t *testing.T) {

 func TestCreateAccount(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, err := NewFlagManager(flagsPath)
 	if err != nil {
@@ -251,9 +226,8 @@ func TestCreateAccount(t *testing.T) {
 			mockAccountService := new(mocks.MockAccountService)

 			h := &MenuHandlers{
-				userdataStore:  userStore,
+				userdataStore:  store,
 				accountService: mockAccountService,
-				logDb:          logDb,
 				flagManager:    fm,
 			}

@@ -291,13 +265,8 @@ func TestWithPersister_PanicWhenAlreadySet(t *testing.T) {

 func TestSaveFirstname(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -313,7 +282,7 @@ func TestSaveFirstname(t *testing.T) {
 	// Define test data
 	firstName := "John"

-	if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(firstName)); err != nil {
+	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(firstName)); err != nil {
 		t.Fatal(err)
 	}

@@ -321,10 +290,9 @@ func TestSaveFirstname(t *testing.T) {

 	// Create the MenuHandlers instance with the mock store
 	h := &MenuHandlers{
-		userdataStore: userStore,
+		userdataStore: store,
 		flagManager:   fm,
 		st:            mockState,
-		logDb:         logDb,
 	}

 	// Call the method
@@ -335,19 +303,14 @@ func TestSaveFirstname(t *testing.T) {
 	assert.Equal(t, expectedResult, res)

 	// Verify that the DATA_FIRST_NAME entry has been updated with the temporary value
-	storedFirstName, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_FIRST_NAME)
+	storedFirstName, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_FIRST_NAME)
 	assert.Equal(t, firstName, string(storedFirstName))
 }

 func TestSaveFamilyname(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -365,16 +328,15 @@ func TestSaveFamilyname(t *testing.T) {
 	// Define test data
 	familyName := "Doeee"

-	if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(familyName)); err != nil {
+	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(familyName)); err != nil {
 		t.Fatal(err)
 	}

 	// Create the MenuHandlers instance with the mock store
 	h := &MenuHandlers{
-		userdataStore: userStore,
+		userdataStore: store,
 		st:            mockState,
 		flagManager:   fm,
-		logDb:         logDb,
 	}

 	// Call the method
@@ -385,19 +347,14 @@ func TestSaveFamilyname(t *testing.T) {
 	assert.Equal(t, expectedResult, res)

 	// Verify that the DATA_FAMILY_NAME entry has been updated with the temporary value
-	storedFamilyName, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_FAMILY_NAME)
+	storedFamilyName, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_FAMILY_NAME)
 	assert.Equal(t, familyName, string(storedFamilyName))
 }

 func TestSaveYoB(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -413,7 +370,7 @@ func TestSaveYoB(t *testing.T) {
 	// Define test data
 	yob := "1980"

-	if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(yob)); err != nil {
+	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(yob)); err != nil {
 		t.Fatal(err)
 	}

@@ -421,10 +378,9 @@ func TestSaveYoB(t *testing.T) {

 	// Create the MenuHandlers instance with the mock store
 	h := &MenuHandlers{
-		userdataStore: userStore,
+		userdataStore: store,
 		flagManager:   fm,
 		st:            mockState,
-		logDb:         logDb,
 	}

 	// Call the method
@@ -435,19 +391,14 @@ func TestSaveYoB(t *testing.T) {
 	assert.Equal(t, expectedResult, res)

 	// Verify that the DATA_YOB entry has been updated with the temporary value
-	storedYob, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_YOB)
+	storedYob, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_YOB)
 	assert.Equal(t, yob, string(storedYob))
 }

 func TestSaveLocation(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -463,7 +414,7 @@ func TestSaveLocation(t *testing.T) {
 	// Define test data
 	location := "Kilifi"

-	if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(location)); err != nil {
+	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(location)); err != nil {
 		t.Fatal(err)
 	}

@@ -471,10 +422,9 @@ func TestSaveLocation(t *testing.T) {

 	// Create the MenuHandlers instance with the mock store
 	h := &MenuHandlers{
-		userdataStore: userStore,
+		userdataStore: store,
 		flagManager:   fm,
 		st:            mockState,
-		logDb:         logDb,
 	}

 	// Call the method
@@ -485,19 +435,14 @@ func TestSaveLocation(t *testing.T) {
 	assert.Equal(t, expectedResult, res)

 	// Verify that the DATA_LOCATION entry has been updated with the temporary value
-	storedLocation, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_LOCATION)
+	storedLocation, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_LOCATION)
 	assert.Equal(t, location, string(storedLocation))
 }

 func TestSaveOfferings(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -513,7 +458,7 @@ func TestSaveOfferings(t *testing.T) {
 	// Define test data
 	offerings := "Bananas"

-	if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(offerings)); err != nil {
+	if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(offerings)); err != nil {
 		t.Fatal(err)
 	}

@@ -521,10 +466,9 @@ func TestSaveOfferings(t *testing.T) {

 	// Create the MenuHandlers instance with the mock store
 	h := &MenuHandlers{
-		userdataStore: userStore,
+		userdataStore: store,
 		flagManager:   fm,
 		st:            mockState,
-		logDb:         logDb,
 	}

 	// Call the method
@@ -535,19 +479,14 @@ func TestSaveOfferings(t *testing.T) {
 	assert.Equal(t, expectedResult, res)

 	// Verify that the DATA_OFFERINGS entry has been updated with the temporary value
-	storedOfferings, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_OFFERINGS)
+	storedOfferings, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_OFFERINGS)
 	assert.Equal(t, offerings, string(storedOfferings))
 }

 func TestSaveGender(t *testing.T) {
 	sessionId := "session123"
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, _ := NewFlagManager(flagsPath)

@@ -587,17 +526,16 @@ func TestSaveGender(t *testing.T) {

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			if err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(tt.expectedGender)); err != nil {
+			if err := store.WriteEntry(ctx, sessionId, storedb.DATA_TEMPORARY_VALUE, []byte(tt.expectedGender)); err != nil {
 				t.Fatal(err)
 			}

 			mockState.ExecPath = append(mockState.ExecPath, tt.executingSymbol)
 			// Create the MenuHandlers instance with the mock store
 			h := &MenuHandlers{
-				userdataStore: userStore,
+				userdataStore: store,
 				st:            mockState,
 				flagManager:   fm,
-				logDb:         logDb,
 			}

 			expectedResult := resource.Result{}
@@ -612,7 +550,7 @@ func TestSaveGender(t *testing.T) {
 			assert.Equal(t, expectedResult, res)

 			// Verify that the DATA_GENDER entry has been updated with the temporary value
-			storedGender, _ := userStore.ReadEntry(ctx, sessionId, storedb.DATA_GENDER)
+			storedGender, _ := store.ReadEntry(ctx, sessionId, storedb.DATA_GENDER)
 			assert.Equal(t, tt.expectedGender, string(storedGender))
 		})
 	}
@@ -628,7 +566,7 @@ func TestSaveTemporaryPin(t *testing.T) {
 		log.Fatal(err)
 	}

-	flag_invalid_pin, _ := fm.GetFlag("flag_invalid_pin")
+	flag_incorrect_pin, _ := fm.GetFlag("flag_incorrect_pin")

 	// Create the MenuHandlers instance with the mock flag manager
 	h := &MenuHandlers{
@@ -646,14 +584,14 @@ func TestSaveTemporaryPin(t *testing.T) {
 			name:  "Valid Pin entry",
 			input: []byte("1234"),
 			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_invalid_pin},
+				FlagReset: []uint32{flag_incorrect_pin},
 			},
 		},
 		{
 			name:  "Invalid Pin entry",
 			input: []byte("12343"),
 			expectedResult: resource.Result{
-				FlagSet: []uint32{flag_invalid_pin},
+				FlagSet: []uint32{flag_incorrect_pin},
 			},
 		},
 	}
@@ -1905,7 +1843,53 @@ func TestGetProfile(t *testing.T) {
 	}
 }

-func TestConfirmPinChange(t *testing.T) {
+func TestVerifyNewPin(t *testing.T) {
+	sessionId := "session123"
+
+	fm, _ := NewFlagManager(flagsPath)
+	mockState := state.NewState(16)
+
+	flag_valid_pin, _ := fm.GetFlag("flag_valid_pin")
+	mockAccountService := new(mocks.MockAccountService)
+	h := &MenuHandlers{
+		flagManager:    fm,
+		accountService: mockAccountService,
+		st:             mockState,
+	}
+	ctx := context.WithValue(context.Background(), "SessionId", sessionId)
+
+	tests := []struct {
+		name           string
+		input          []byte
+		expectedResult resource.Result
+	}{
+		{
+			name:  "Test with valid pin",
+			input: []byte("1234"),
+			expectedResult: resource.Result{
+				FlagSet: []uint32{flag_valid_pin},
+			},
+		},
+		{
+			name:  "Test with invalid pin",
+			input: []byte("123"),
+			expectedResult: resource.Result{
+				FlagReset: []uint32{flag_valid_pin},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			//Call the function under test
+			res, _ := h.VerifyNewPin(ctx, "verify_new_pin", tt.input)
+
+			//Assert that the result set to content is what was expected
+			assert.Equal(t, res, tt.expectedResult, "Result should contain flags set according to user input")
+		})
+	}
+}
+
+func TestConfirmPin(t *testing.T) {
 	sessionId := "session123"

 	mockState := state.NewState(16)
@@ -1914,8 +1898,6 @@ func TestConfirmPinChange(t *testing.T) {

 	fm, _ := NewFlagManager(flagsPath)
 	flag_pin_mismatch, _ := fm.GetFlag("flag_pin_mismatch")
-	flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
-
 	mockAccountService := new(mocks.MockAccountService)
 	h := &MenuHandlers{
 		userdataStore:  store,
@@ -1935,7 +1917,7 @@ func TestConfirmPinChange(t *testing.T) {
 			input:        []byte("1234"),
 			temporarypin: "1234",
 			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_pin_mismatch, flag_account_pin_reset},
+				FlagReset: []uint32{flag_pin_mismatch},
 			},
 		},
 	}
@@ -2008,51 +1990,36 @@ func TestFetchCommunityBalance(t *testing.T) {
 	}
 }

-func TestManageVouchers(t *testing.T) {
+func TestSetDefaultVoucher(t *testing.T) {
 	sessionId := "session123"
-	publicKey := "0X13242618721"
-
-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}

 	fm, err := NewFlagManager(flagsPath)
 	if err != nil {
-		t.Fatal(err)
+		t.Logf(err.Error())
 	}
 	flag_no_active_voucher, err := fm.GetFlag("flag_no_active_voucher")
 	if err != nil {
-		t.Fatal(err)
+		t.Logf(err.Error())
 	}

-	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
-	if err != nil {
-		t.Fatal(err)
-	}
+	publicKey := "0X13242618721"

 	tests := []struct {
-		name                   string
-		vouchersResp           []dataserviceapi.TokenHoldings
-		storedActiveVoucher    string
-		expectedVoucherSymbols []byte
-		expectedUpdatedAddress []byte
-		expectedResult         resource.Result
+		name           string
+		vouchersResp   []dataserviceapi.TokenHoldings
+		expectedResult resource.Result
 	}{
 		{
-			name:                   "No vouchers available",
-			vouchersResp:           []dataserviceapi.TokenHoldings{},
-			expectedVoucherSymbols: []byte(""),
-			expectedUpdatedAddress: []byte(""),
+			name:         "Test no vouchers available",
+			vouchersResp: []dataserviceapi.TokenHoldings{},
 			expectedResult: resource.Result{
 				FlagSet: []uint32{flag_no_active_voucher},
 			},
 		},
 		{
-			name: "Set default voucher when no active voucher is set",
+			name: "Test set default voucher when no active voucher is set",
 			vouchersResp: []dataserviceapi.TokenHoldings{
 				{
 					ContractAddress: "0x123",
@@ -2061,24 +2028,7 @@ func TestManageVouchers(t *testing.T) {
 					Balance:         "100",
 				},
 			},
-			expectedVoucherSymbols: []byte("1:TOKEN1"),
-			expectedUpdatedAddress: []byte("0x123"),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_no_active_voucher},
-			},
-		},
-		{
-			name: "Check and update active voucher balance",
-			vouchersResp: []dataserviceapi.TokenHoldings{
-				{ContractAddress: "0xd4c288865Ce", TokenSymbol: "SRF", TokenDecimals: "6", Balance: "100"},
-				{ContractAddress: "0x41c188d63Qa", TokenSymbol: "MILO", TokenDecimals: "4", Balance: "200"},
-			},
-			storedActiveVoucher:    "SRF",
-			expectedVoucherSymbols: []byte("1:SRF\n2:MILO"),
-			expectedUpdatedAddress: []byte("0xd4c288865Ce"),
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_no_active_voucher},
-			},
+			expectedResult: resource.Result{},
 		},
 	}

@@ -2087,47 +2037,90 @@ func TestManageVouchers(t *testing.T) {
 			mockAccountService := new(mocks.MockAccountService)

 			h := &MenuHandlers{
-				userdataStore:  userStore,
+				userdataStore:  store,
 				accountService: mockAccountService,
 				flagManager:    fm,
-				logDb:          logDb,
+			}
+
+			err := store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
+			if err != nil {
+				t.Fatal(err)
 			}

 			mockAccountService.On("FetchVouchers", string(publicKey)).Return(tt.vouchersResp, nil)

-			// Store active voucher if needed
-			if tt.storedActiveVoucher != "" {
-				err := userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte(tt.storedActiveVoucher))
-				if err != nil {
-					t.Fatal(err)
-				}
-				err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte("0x41c188D45rfg6ds"))
-				if err != nil {
-					t.Fatal(err)
-				}
-			}
+			res, err := h.SetDefaultVoucher(ctx, "set_default_voucher", []byte("some-input"))

-			res, err := h.ManageVouchers(ctx, "manage_vouchers", []byte(""))
 			assert.NoError(t, err)
-			assert.Equal(t, tt.expectedResult, res)

-			if tt.storedActiveVoucher != "" {
-				// Validate stored voucher symbols
-				voucherData, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_VOUCHER_SYMBOLS)
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expectedVoucherSymbols, voucherData)
+			assert.Equal(t, res, tt.expectedResult, "Expected result should be equal to the actual result")

-				// Validate stored active contract address
-				updatedAddress, err := userStore.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expectedUpdatedAddress, updatedAddress)
-
-				mockAccountService.AssertExpectations(t)
-			}
+			mockAccountService.AssertExpectations(t)
 		})
 	}
 }

+func TestCheckVouchers(t *testing.T) {
+	mockAccountService := new(mocks.MockAccountService)
+	sessionId := "session123"
+	publicKey := "0X13242618721"
+
+	ctx, store := InitializeTestStore(t)
+	ctx = context.WithValue(ctx, "SessionId", sessionId)
+
+	h := &MenuHandlers{
+		userdataStore:  store,
+		accountService: mockAccountService,
+	}
+
+	err := store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mockVouchersResponse := []dataserviceapi.TokenHoldings{
+		{ContractAddress: "0xd4c288865Ce", TokenSymbol: "SRF", TokenDecimals: "6", Balance: "100"},
+		{ContractAddress: "0x41c188d63Qa", TokenSymbol: "MILO", TokenDecimals: "4", Balance: "200"},
+	}
+
+	// store the default voucher data
+	err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_SYM, []byte("SRF"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = store.WriteEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS, []byte("0x41c188D45rfg6ds"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedSym := []byte("1:SRF\n2:MILO")
+	expectedUpdatedAddress := []byte("0xd4c288865Ce")
+
+	mockAccountService.On("FetchVouchers", string(publicKey)).Return(mockVouchersResponse, nil)
+
+	_, err = h.CheckVouchers(ctx, "check_vouchers", []byte(""))
+	assert.NoError(t, err)
+
+	// Read voucher sym data from the store
+	voucherData, err := store.ReadEntry(ctx, sessionId, storedb.DATA_VOUCHER_SYMBOLS)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Read active contract address from the store
+	updatedAddress, err := store.ReadEntry(ctx, sessionId, storedb.DATA_ACTIVE_ADDRESS)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// assert that the data is stored correctly
+	assert.Equal(t, expectedSym, voucherData)
+	// assert that the address is updated
+	assert.Equal(t, expectedUpdatedAddress, updatedAddress)
+
+	mockAccountService.AssertExpectations(t)
+}
+
 func TestGetVoucherList(t *testing.T) {
 	sessionId := "session123"

@@ -2360,8 +2353,10 @@ func TestCheckBlockedStatus(t *testing.T) {
 	if err != nil {
 		t.Logf(err.Error())
 	}
-	flag_account_blocked, _ := fm.GetFlag("flag_account_blocked")
-	flag_account_pin_reset, _ := fm.GetFlag("flag_account_pin_reset")
+	flag_account_blocked, err := fm.GetFlag("flag_account_blocked")
+	if err != nil {
+		t.Logf(err.Error())
+	}

 	h := &MenuHandlers{
 		userdataStore: store,
@@ -2376,15 +2371,13 @@ func TestCheckBlockedStatus(t *testing.T) {
 		{
 			name:                    "Currently blocked account",
 			currentWrongPinAttempts: "4",
-			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_account_pin_reset},
-			},
+			expectedResult:          resource.Result{},
 		},
 		{
 			name:                    "Account with 0 wrong PIN attempts",
 			currentWrongPinAttempts: "0",
 			expectedResult: resource.Result{
-				FlagReset: []uint32{flag_account_pin_reset, flag_account_blocked},
+				FlagReset: []uint32{flag_account_blocked},
 			},
 		},
 	}
@@ -2445,14 +2438,8 @@ func TestCheckTransactions(t *testing.T) {
 	sessionId := "session123"
 	publicKey := "0X13242618721"

-	ctx, userStore := InitializeTestStore(t)
+	ctx, store := InitializeTestStore(t)
 	ctx = context.WithValue(ctx, "SessionId", sessionId)
-	_, logdb := InitializeTestLogdbStore(t)
-
-	logDb := store.LogDb{
-		Db: logdb,
-	}
-
 	spdb := InitializeTestSubPrefixDb(t, ctx)

 	fm, err := NewFlagManager(flagsPath)
@@ -2461,14 +2448,13 @@ func TestCheckTransactions(t *testing.T) {
 	}

 	h := &MenuHandlers{
-		userdataStore:  userStore,
+		userdataStore:  store,
 		accountService: mockAccountService,
 		prefixDb:       spdb,
-		logDb:          logDb,
 		flagManager:    fm,
 	}

-	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
+	err = store.WriteEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY, []byte(publicKey))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2920,6 +2906,173 @@ func TestValidateBlockedNumber(t *testing.T) {
 	}
 }

+func TestSaveOthersTemporaryPin(t *testing.T) {
+	sessionId := "session123"
+	blockedNumber := "+254712345678"
+	testPin := "1234"
+
+	ctx, userStore := InitializeTestStore(t)
+	ctx = context.WithValue(ctx, "SessionId", sessionId)
+
+	h := &MenuHandlers{
+		userdataStore: userStore,
+	}
+
+	tests := []struct {
+		name          string
+		sessionId     string
+		blockedNumber string
+		testPin       string
+		setup         func() error // Setup function for each test case
+		expectedError bool
+		verifyResult  func(t *testing.T) // Function to verify the result
+	}{
+		{
+			name:          "Missing Session ID",
+			sessionId:     "", // Empty session ID
+			blockedNumber: blockedNumber,
+			testPin:       testPin,
+			setup:         nil,
+			expectedError: true,
+			verifyResult:  nil,
+		},
+		{
+			name:          "Failed to Read Blocked Number",
+			sessionId:     sessionId,
+			blockedNumber: blockedNumber,
+			testPin:       testPin,
+			setup: func() error {
+				// Do not write the blocked number to simulate a read failure
+				return nil
+			},
+			expectedError: true,
+			verifyResult:  nil,
+		},
+
+		{
+			name:          "Successfully save hashed PIN",
+			sessionId:     sessionId,
+			blockedNumber: blockedNumber,
+			testPin:       testPin,
+			setup: func() error {
+				// Write the blocked number to the store
+				return userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber))
+			},
+			expectedError: false,
+			verifyResult: func(t *testing.T) {
+				// Read the stored hashed PIN
+				othersHashedPin, err := userStore.ReadEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE)
+				if err != nil {
+					t.Fatal(err)
+				}
+
+				// Verify that the stored hashed PIN matches the original PIN
+				if !pin.VerifyPIN(string(othersHashedPin), testPin) {
+					t.Fatal("stored hashed PIN does not match the original PIN")
+				}
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Set up the context with the session ID
+			ctx := context.WithValue(context.Background(), "SessionId", tt.sessionId)
+
+			// Run the setup function if provided
+			if tt.setup != nil {
+				err := tt.setup()
+				if err != nil {
+					t.Fatal(err)
+				}
+			}
+
+			// Call the function under test
+			_, err := h.SaveOthersTemporaryPin(ctx, "save_others_temporary_pin", []byte(tt.testPin))
+
+			// Assert the error
+			if tt.expectedError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			// Verify the result if a verification function is provided
+			if tt.verifyResult != nil {
+				tt.verifyResult(t)
+			}
+		})
+	}
+}
+
+func TestCheckBlockedNumPinMisMatch(t *testing.T) {
+	sessionId := "session123"
+	blockedNumber := "+254712345678"
+	testPin := "1234"
+	mockState := state.NewState(128)
+
+	ctx, userStore := InitializeTestStore(t)
+	ctx = context.WithValue(ctx, "SessionId", sessionId)
+
+	hashedPIN, err := pin.HashPIN(testPin)
+	if err != nil {
+		logg.ErrorCtxf(ctx, "failed to hash testPin", "error", err)
+		t.Fatal(err)
+	}
+
+	fm, err := NewFlagManager(flagsPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	flag_pin_mismatch, _ := fm.GetFlag("flag_pin_mismatch")
+
+	h := &MenuHandlers{
+		userdataStore: userStore,
+		st:            mockState,
+		flagManager:   fm,
+	}
+
+	// Write initial data to the store
+	err = userStore.WriteEntry(ctx, sessionId, storedb.DATA_BLOCKED_NUMBER, []byte(blockedNumber))
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = userStore.WriteEntry(ctx, blockedNumber, storedb.DATA_TEMPORARY_VALUE, []byte(hashedPIN))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tests := []struct {
+		name           string
+		input          []byte
+		expectedResult resource.Result
+	}{
+		{
+			name:  "Successful PIN match",
+			input: []byte(testPin),
+			expectedResult: resource.Result{
+				FlagReset: []uint32{flag_pin_mismatch},
+			},
+		},
+		{
+			name:  "PIN mismatch",
+			input: []byte("1345"),
+			expectedResult: resource.Result{
+				FlagSet: []uint32{flag_pin_mismatch},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			res, err := h.CheckBlockedNumPinMisMatch(ctx, "sym", tt.input)
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expectedResult, res)
+		})
+	}
+}
+
 func TestGetCurrentProfileInfo(t *testing.T) {
 	sessionId := "session123"
 	ctx, store := InitializeTestStore(t)
@@ -3076,6 +3229,30 @@ func TestResetOthersPin(t *testing.T) {
 	assert.NoError(t, err)
 }

+func TestResetValidPin(t *testing.T) {
+	ctx := context.Background()
+
+	fm, err := NewFlagManager(flagsPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	flag_valid_pin, _ := fm.GetFlag("flag_valid_pin")
+
+	expectedResult := resource.Result{
+		FlagReset: []uint32{flag_valid_pin},
+	}
+
+	h := &MenuHandlers{
+		flagManager: fm,
+	}
+
+	res, err := h.ResetValidPin(ctx, "reset_valid_pin", []byte(""))
+
+	assert.NoError(t, err)
+
+	assert.Equal(t, expectedResult, res)
+}
+
 func TestResetUnregisteredNumber(t *testing.T) {
 	ctx := context.Background()

--- a/handlers/local.go
+++ b/handlers/local.go
@@ -27,7 +27,6 @@ type LocalHandlerService struct {
 	DbRs          *resource.DbResource
 	Pe            *persist.Persister
 	UserdataStore *db.Db
-	LogDb         *db.Db
 	Cfg           engine.Config
 	Rs            resource.Resource
 	first         resource.EntryFunc
@@ -58,16 +57,12 @@ func (ls *LocalHandlerService) SetDataStore(db *db.Db) {
 	ls.UserdataStore = db
 }

-func (ls *LocalHandlerService) SetLogDb(db *db.Db) {
-	ls.LogDb = db
-}
-
 func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService) (*application.MenuHandlers, error) {
 	replaceSeparatorFunc := func(input string) string {
 		return strings.ReplaceAll(input, ":", ls.Cfg.MenuSeparator)
 	}

-	appHandlers, err := application.NewMenuHandlers(ls.Parser, *ls.UserdataStore, *ls.LogDb, accountService, replaceSeparatorFunc)
+	appHandlers, err := application.NewMenuHandlers(ls.Parser, *ls.UserdataStore, accountService, replaceSeparatorFunc)
 	if err != nil {
 		return nil, err
 	}
@@ -104,18 +99,23 @@ func (ls *LocalHandlerService) GetHandler(accountService remote.AccountService)
 	ls.DbRs.AddLocalFunc("verify_yob", appHandlers.VerifyYob)
 	ls.DbRs.AddLocalFunc("reset_incorrect_date_format", appHandlers.ResetIncorrectYob)
 	ls.DbRs.AddLocalFunc("initiate_transaction", appHandlers.InitiateTransaction)
+	ls.DbRs.AddLocalFunc("verify_new_pin", appHandlers.VerifyNewPin)
 	ls.DbRs.AddLocalFunc("confirm_pin_change", appHandlers.ConfirmPinChange)
 	ls.DbRs.AddLocalFunc("quit_with_help", appHandlers.QuitWithHelp)
 	ls.DbRs.AddLocalFunc("fetch_community_balance", appHandlers.FetchCommunityBalance)
-	ls.DbRs.AddLocalFunc("manage_vouchers", appHandlers.ManageVouchers)
+	ls.DbRs.AddLocalFunc("set_default_voucher", appHandlers.SetDefaultVoucher)
+	ls.DbRs.AddLocalFunc("check_vouchers", appHandlers.CheckVouchers)
 	ls.DbRs.AddLocalFunc("get_vouchers", appHandlers.GetVoucherList)
 	ls.DbRs.AddLocalFunc("view_voucher", appHandlers.ViewVoucher)
 	ls.DbRs.AddLocalFunc("set_voucher", appHandlers.SetVoucher)
 	ls.DbRs.AddLocalFunc("get_voucher_details", appHandlers.GetVoucherDetails)
+	ls.DbRs.AddLocalFunc("reset_valid_pin", appHandlers.ResetValidPin)
+	ls.DbRs.AddLocalFunc("check_pin_mismatch", appHandlers.CheckBlockedNumPinMisMatch)
 	ls.DbRs.AddLocalFunc("validate_blocked_number", appHandlers.ValidateBlockedNumber)
 	ls.DbRs.AddLocalFunc("retrieve_blocked_number", appHandlers.RetrieveBlockedNumber)
 	ls.DbRs.AddLocalFunc("reset_unregistered_number", appHandlers.ResetUnregisteredNumber)
 	ls.DbRs.AddLocalFunc("reset_others_pin", appHandlers.ResetOthersPin)
+	ls.DbRs.AddLocalFunc("save_others_temporary_pin", appHandlers.SaveOthersTemporaryPin)
 	ls.DbRs.AddLocalFunc("get_current_profile_info", appHandlers.GetCurrentProfileInfo)
 	ls.DbRs.AddLocalFunc("check_transactions", appHandlers.CheckTransactions)
 	ls.DbRs.AddLocalFunc("get_transactions", appHandlers.GetTransactionsList)
--- a/internal/cmd/cmd.go
+++ b/internal/cmd/cmd.go
@@ -5,21 +5,32 @@ import (
 	"fmt"

 	"git.defalsify.org/vise.git/logging"
+	"git.defalsify.org/vise.git/engine"
+	"git.defalsify.org/vise.git/persist"
+	"git.defalsify.org/vise.git/resource"
+	"git.defalsify.org/vise.git/state"
 	"git.grassecon.net/grassrootseconomics/sarafu-vise/handlers/application"
 	"git.grassecon.net/grassrootseconomics/visedriver/storage"
 )

+var argc map[string]int = map[string]int{
+	"reset": 0,
+	"admin": 1,
+}
+
 var (
 	logg = logging.NewVanilla().WithDomain("cmd").WithContextKey("SessionId")
 )

 type Cmd struct {
-	sessionId  string
-	conn       storage.ConnData
-	flagParser *application.FlagManager
-	cmd        int
-	enable     bool
-	exec       func(ctx context.Context, ss storage.StorageService) error
+	sessionId    string
+	conn         storage.ConnData
+	flagParser   *application.FlagManager
+	cmd          int
+	enable       bool
+	exec         func(ctx context.Context, ss storage.StorageService) error
+	engineConfig *engine.Config
+	st           *state.State
 }

 func NewCmd(sessionId string, flagParser *application.FlagManager) *Cmd {
@@ -29,10 +40,74 @@ func NewCmd(sessionId string, flagParser *application.FlagManager) *Cmd {
 	}
 }

+func (c *Cmd) WithEngine(engineConfig engine.Config) *Cmd {
+	c.engineConfig = &engineConfig
+	return c
+}
+
 func (c *Cmd) Exec(ctx context.Context, ss storage.StorageService) error {
 	return c.exec(ctx, ss)
 }

+func (c *Cmd) engine(ctx context.Context, rs resource.Resource, pe *persist.Persister) (engine.Engine, error) {
+	if c.engineConfig == nil {
+		return nil, fmt.Errorf("engine config missing")
+	}
+	en := engine.NewEngine(*c.engineConfig, rs)
+
+	st := pe.GetState()
+	if st == nil {
+		return nil, fmt.Errorf("persister state fail")
+	}
+	en = en.WithState(st)
+	st.UseDebug()
+	ca := pe.GetMemory()
+	if ca == nil {
+		return nil, fmt.Errorf("persister cache fail")
+	}
+	en = en.WithMemory(ca)
+	logg.DebugCtxf(ctx, "state loaded", "state", st)
+	return en, nil
+}
+
+func (c *Cmd) execReset(ctx context.Context, ss storage.StorageService) error {
+	pe, err := ss.GetPersister(ctx)
+	if err != nil {
+		return fmt.Errorf("get persister error: %v", err)
+	}
+	rs, err := ss.GetResource(ctx)
+	if err != nil {
+		return fmt.Errorf("get resource error: %v", err)
+	}
+	dbResource, ok := rs.(*resource.DbResource)
+	if !ok {
+		return fmt.Errorf("get dbresource error: %v", err)
+	}
+	err = pe.Load(c.engineConfig.SessionId)
+	if err != nil {
+		return fmt.Errorf("persister load error: %v", err)
+	}
+	en, err := c.engine(ctx, dbResource, pe)
+	if err != nil {
+		return err
+	}
+	ca := pe.GetMemory()
+	ca.Pop()
+
+	_, err = en.(*engine.DefaultEngine).Reset(ctx, false)
+	if err != nil {
+		return err
+	}
+	st := pe.GetState()
+	logg.DebugCtxf(ctx, "state after reset", "state", st)
+
+	err = pe.Save(c.engineConfig.SessionId)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func (c *Cmd) execAdmin(ctx context.Context, ss storage.StorageService) error {
 	pe, err := ss.GetPersister(ctx)
 	if err != nil {
@@ -76,13 +151,33 @@ func (c *Cmd) parseCmdAdmin(cmd string, param string, more []string) (bool, erro
 	return false, nil
 }

+func (c *Cmd) parseCmdReset(cmd string, param string, more []string) (bool, error) {
+	if cmd == "reset" {
+		c.enable = false
+		c.exec = c.execReset
+		return true, nil
+	}
+	return false, nil
+}
+
 func (c *Cmd) Parse(args []string) error {
-	if len(args) < 2 {
+	var param string
+	if len(args) < 1 {
 		return fmt.Errorf("Wrong number of arguments: %v", args)
 	}
 	cmd := args[0]
-	param := args[1]
-	args = args[2:]
+
+	n, ok := argc[cmd]
+	if !ok {
+		return fmt.Errorf("invalid command: %v", cmd)
+	}
+	if n > 0 {
+		if len(args) < n+1 {
+			return fmt.Errorf("Wrong number of arguments, need: %d", n)
+		}
+		param = args[1]
+		args = args[2:]
+	}

 	r, err := c.parseCmdAdmin(cmd, param, args)
 	if err != nil {
@@ -92,5 +187,13 @@ func (c *Cmd) Parse(args []string) error {
 		return nil
 	}

+	r, err = c.parseCmdReset(cmd, param, args)
+	if err != nil {
+		return err
+	}
+	if r {
+		return nil
+	}
+
 	return fmt.Errorf("unknown subcommand: %s", cmd)
 }
--- a/internal/sms/sms.go
+++ b/internal/sms/sms.go
@@ -1,96 +0,0 @@
-package sms
-
-import (
-	"context"
-	"fmt"
-
-	"git.defalsify.org/vise.git/logging"
-	"git.grassecon.net/grassrootseconomics/common/phone"
-	"git.grassecon.net/grassrootseconomics/sarafu-api/remote"
-	"git.grassecon.net/grassrootseconomics/sarafu-vise/store"
-	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
-)
-
-var (
-	logg = logging.NewVanilla().WithDomain("smsservice")
-)
-
-type SmsService struct {
-	Accountservice remote.AccountService
-	Userdatastore  store.UserDataStore
-}
-
-// SendUpsellSMS will send an invitation SMS to an unregistered phone number
-func (smsservice *SmsService) SendUpsellSMS(ctx context.Context, inviterPhone, inviteePhone string) error {
-	if !phone.IsValidPhoneNumber(inviterPhone) {
-		return fmt.Errorf("invalid inviter phone number %v", inviterPhone)
-	}
-
-	if !phone.IsValidPhoneNumber(inviteePhone) {
-		return fmt.Errorf("Invalid invitee phone number %v", inviteePhone)
-	}
-	_, err := smsservice.Accountservice.SendUpsellSMS(ctx, inviterPhone, inviteePhone)
-	if err != nil {
-		return fmt.Errorf("Failed to send upsell sms: %v", err)
-	}
-	return nil
-}
-
-// sendPINResetSMS will send an SMS to a user's phonenumber in the event that the associated account's PIN has been reset.
-func (smsService *SmsService) SendPINResetSMS(ctx context.Context, adminPhoneNumber, blockedPhoneNumber string) error {
-	formattedAdminPhone, err := phone.FormatPhoneNumber(adminPhoneNumber)
-	if err != nil {
-		return fmt.Errorf("failed to format admin phone number: %w", err)
-	}
-
-	formattedBlockedPhone, err := phone.FormatPhoneNumber(blockedPhoneNumber)
-	if err != nil {
-		return fmt.Errorf("failed to format blocked phone number: %w", err)
-	}
-
-	if !phone.IsValidPhoneNumber(formattedAdminPhone) {
-		return fmt.Errorf("invalid admin phone number")
-	}
-	if !phone.IsValidPhoneNumber(formattedBlockedPhone) {
-		return fmt.Errorf("invalid blocked phone number")
-	}
-
-	err = smsService.Accountservice.SendPINResetSMS(ctx, formattedAdminPhone, formattedBlockedPhone)
-	if err != nil {
-		return fmt.Errorf("failed to send pin reset sms: %v", err)
-	}
-
-	return nil
-}
-
-// SendAddressSMS will triger an SMS when a user navigates to the my address node.The SMS will be sent to the associated phonenumber.
-func (smsService *SmsService) SendAddressSMS(ctx context.Context) error {
-	store := smsService.Userdatastore
-	sessionId, ok := ctx.Value("SessionId").(string)
-	if !ok {
-		return fmt.Errorf("missing session")
-	}
-
-	publicKey, err := store.ReadEntry(ctx, sessionId, storedb.DATA_PUBLIC_KEY)
-	if err != nil {
-		logg.ErrorCtxf(ctx, "failed to read publicKey entry with", "key", storedb.DATA_PUBLIC_KEY, "error", err)
-		return err
-	}
-
-	originPhone, err := phone.FormatPhoneNumber(sessionId)
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to format origin phonenumber", "sessionid", sessionId)
-		return nil
-	}
-
-	if !phone.IsValidPhoneNumber(originPhone) {
-		logg.InfoCtxf(ctx, "Invalid origin phone number", "origin phonenumber", originPhone)
-		return fmt.Errorf("invalid origin phone number")
-	}
-	err = smsService.Accountservice.SendAddressSMS(ctx, string(publicKey), originPhone)
-	if err != nil {
-		logg.DebugCtxf(ctx, "Failed to send address sms", "error", err)
-		return fmt.Errorf("Failed to send address sms: %v", err)
-	}
-	return nil
-}
--- a/menutraversal_test/group_test.json
+++ b/menutraversal_test/group_test.json
@@ -202,7 +202,23 @@
                },
                {
                    "input": "0700000000",
-                    "expectedContent": "{secondary_session_id} will get a PIN reset request.\nPlease enter your PIN to confirm:\n0:Back\n9:Quit"
+                    "expectedContent": "Please enter new PIN for: {secondary_session_id}\n0:Back"
+                },
+                {
+                    "input": "11111",
+                    "expectedContent": "The PIN you have entered is invalid.Please try a 4 digit number instead.\n1:Retry\n9:Quit"
+                },
+                {
+                    "input": "1",
+                    "expectedContent": "Please enter new PIN for: {secondary_session_id}\n0:Back"
+                },
+                {
+                    "input": "1111",
+                    "expectedContent": "Please confirm new PIN for: {secondary_session_id}\n0:Back"
+                },
+                {
+                    "input": "1111",
+                    "expectedContent": "Please enter your PIN:"
                },
                {
                    "input": "1234",
@@ -596,7 +612,7 @@
                },
                {
                    "input": "1234",
-                    "expectedContent": "My profile:\nName: foo bar\nGender: male\nAge: 80\nLocation: Kilifi\nYou provide: Bananas\nYour alias: Not Provided\n\n0:Back\n9:Quit"
+                    "expectedContent": "My profile:\nName: foo bar\nGender: male\nAge: 80\nLocation: Kilifi\nYou provide: Bananas\nYour alias: \n\n0:Back\n9:Quit"
                },
                {
                    "input": "0",
--- a/services/registration/address.vis
+++ b/services/registration/address.vis
@@ -1,4 +1,5 @@
 LOAD check_identifier 0
+RELOAD check_identifier
 MAP check_identifier
 MOUT back 0
 MOUT quit 9
--- a/services/registration/amount.vis
+++ b/services/registration/amount.vis
@@ -6,7 +6,7 @@ MOUT back 0
 HALT
 LOAD validate_amount 64
 RELOAD validate_amount
-CATCH api_failure flag_api_call_error 1
+CATCH api_failure flag_api_call_error  1
 CATCH invalid_amount flag_invalid_amount 1
 INCMP _ 0
 LOAD get_recipient 0
--- a/services/registration/authorize_reset_others_pin
+++ b/services/registration/authorize_reset_others_pin
@@ -1,2 +0,0 @@
-{{.retrieve_blocked_number}} will get a PIN reset request.
-Please enter your PIN to confirm:
--- a/services/registration/authorize_reset_others_pin.vis
+++ b/services/registration/authorize_reset_others_pin.vis
@@ -1,12 +0,0 @@
-LOAD retrieve_blocked_number 0
-RELOAD retrieve_blocked_number
-MAP retrieve_blocked_number
-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 pin_reset_result *
--- a/services/registration/authorize_reset_others_pin_swa
+++ b/services/registration/authorize_reset_others_pin_swa
@@ -1,2 +0,0 @@
-{{.retrieve_blocked_number}} atapokea ombi la kuweka upya PIN.
-Tafadhali weka PIN yako kudhibitisha:
--- a/services/registration/community_balance.vis
+++ b/services/registration/community_balance.vis
@@ -1,6 +1,6 @@
 LOAD reset_incorrect 6
 LOAD fetch_community_balance 0
-CATCH api_failure flag_api_call_error 1
+CATCH api_failure  flag_api_call_error  1
 MAP fetch_community_balance
 CATCH incorrect_pin flag_incorrect_pin 1
 CATCH pin_entry flag_account_authorized 0
--- a/services/registration/confirm_create_pin.vis
+++ b/services/registration/confirm_create_pin.vis
@@ -1,7 +1,4 @@
-MOUT back 0
+LOAD save_temporary_pin 6
 HALT
-INCMP _ 0
 LOAD verify_create_pin 8
-RELOAD verify_create_pin
-CATCH pin_mismatch flag_pin_mismatch 1
 INCMP account_creation *
--- a/services/registration/confirm_new_alias.vis
+++ b/services/registration/confirm_new_alias.vis
@@ -8,5 +8,5 @@ HALT
 INCMP _ 0
 RELOAD authorize_account
 CATCH incorrect_pin flag_incorrect_pin 1
-CATCH invalid_pin flag_invalid_pin 1
+CATCH invalid_pin flag_invalid_pin   1
 CATCH update_alias flag_allow_update 1
--- a/services/registration/confirm_others_new_pin
+++ b/services/registration/confirm_others_new_pin
@@ -0,0 +1 @@
+Please confirm new PIN for: {{.retrieve_blocked_number}}
--- a/services/registration/confirm_others_new_pin.vis
+++ b/services/registration/confirm_others_new_pin.vis
@@ -0,0 +1,14 @@
+CATCH incorrect_pin flag_incorrect_pin 1
+RELOAD retrieve_blocked_number
+MAP retrieve_blocked_number
+CATCH invalid_others_pin flag_valid_pin 0
+CATCH pin_reset_result flag_account_authorized 1
+LOAD save_others_temporary_pin 6
+RELOAD save_others_temporary_pin
+MOUT back 0
+HALT 
+INCMP _ 0
+LOAD check_pin_mismatch 6
+RELOAD check_pin_mismatch
+CATCH others_pin_mismatch flag_pin_mismatch 1
+INCMP pin_entry *
--- a/services/registration/confirm_others_new_pin_swa
+++ b/services/registration/confirm_others_new_pin_swa
@@ -0,0 +1 @@
+Tafadhali thibitisha PIN mpya ya: {{.retrieve_blocked_number}}
--- a/services/registration/confirm_pin_change.vis
+++ b/services/registration/confirm_pin_change.vis
@@ -1,7 +1,7 @@
+LOAD confirm_pin_change 0
 MOUT back 0
 HALT
 INCMP _ 0
-LOAD confirm_pin_change 0
 RELOAD confirm_pin_change
-CATCH pin_mismatch flag_pin_mismatch 1
-INCMP pin_reset_success *
+CATCH pin_reset_mismatch  flag_pin_mismatch 1
+INCMP * pin_reset_success
--- a/services/registration/create_pin.vis
+++ b/services/registration/create_pin.vis
@@ -2,8 +2,8 @@ LOAD create_account 0
 CATCH account_creation_failed flag_account_creation_failed 1
 MOUT exit 0
 HALT
-INCMP quit 0
 LOAD save_temporary_pin 6
 RELOAD save_temporary_pin
-CATCH invalid_pin flag_invalid_pin 1
+CATCH . flag_incorrect_pin 1
+INCMP quit 0
 INCMP confirm_create_pin *
--- a/services/registration/create_pin_mismatch
+++ b/services/registration/create_pin_mismatch
--- a/services/registration/create_pin_mismatch.vis
+++ b/services/registration/create_pin_mismatch.vis
@@ -0,0 +1,5 @@
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP confirm_create_pin 1
+INCMP quit 9
--- a/services/registration/create_pin_mismatch_swa
+++ b/services/registration/create_pin_mismatch_swa
--- a/services/registration/enter_other_number.vis
+++ b/services/registration/enter_other_number.vis
@@ -7,4 +7,4 @@ INCMP _ 0
 LOAD validate_blocked_number 6
 RELOAD validate_blocked_number
 CATCH unregistered_number flag_unregistered_number 1
-INCMP authorize_reset_others_pin *
+INCMP enter_others_new_pin *
--- a/services/registration/enter_others_new_pin
+++ b/services/registration/enter_others_new_pin
@@ -0,0 +1 @@
+Please enter new PIN for: {{.retrieve_blocked_number}}
--- a/services/registration/enter_others_new_pin.vis
+++ b/services/registration/enter_others_new_pin.vis
@@ -0,0 +1,9 @@
+LOAD retrieve_blocked_number 0
+RELOAD retrieve_blocked_number
+MAP retrieve_blocked_number
+MOUT back 0
+HALT 
+LOAD verify_new_pin 6
+RELOAD verify_new_pin
+INCMP _ 0
+INCMP * confirm_others_new_pin
--- a/services/registration/enter_others_new_pin_swa
+++ b/services/registration/enter_others_new_pin_swa
@@ -0,0 +1 @@
+Tafadhali weka PIN mpya ya: {{.retrieve_blocked_number}}
--- a/services/registration/invalid_others_pin
+++ b/services/registration/invalid_others_pin
@@ -0,0 +1 @@
+The PIN you have entered is invalid.Please try a 4 digit number instead.
--- a/services/registration/invalid_others_pin.vis
+++ b/services/registration/invalid_others_pin.vis
@@ -0,0 +1,5 @@
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP enter_others_new_pin 1
+INCMP quit 9
--- a/services/registration/invalid_pin
+++ b/services/registration/invalid_pin
@@ -1 +1 @@
-The PIN you entered is invalid. The PIN must be a 4 digit number.
+The PIN you entered is invalid.The PIN must be a 4 digit number.
--- a/services/registration/main.vis
+++ b/services/registration/main.vis
@@ -1,7 +1,9 @@
 LOAD clear_temporary_value 2
 RELOAD clear_temporary_value
-LOAD manage_vouchers 160
-RELOAD manage_vouchers
+LOAD set_default_voucher 8
+RELOAD set_default_voucher
+LOAD check_vouchers 10
+RELOAD check_vouchers
 LOAD check_balance 128
 RELOAD check_balance
 CATCH api_failure flag_api_call_error 1
--- a/services/registration/my_account.vis
+++ b/services/registration/my_account.vis
@@ -9,7 +9,7 @@ MOUT my_address 6
 MOUT my_account_alias 7
 MOUT back 0
 HALT
-INCMP ^ 0
+INCMP main 0
 INCMP edit_profile 1
 INCMP change_language 2
 INCMP balances 3
--- a/services/registration/my_account_alias
+++ b/services/registration/my_account_alias
@@ -1,2 +1,2 @@
 Current alias: {{.get_current_profile_info}}
-Enter your preferred alias:
+Enter your preferred alias::
--- a/services/registration/my_account_alias.vis
+++ b/services/registration/my_account_alias.vis
@@ -5,4 +5,4 @@ HALT
 INCMP _ 0
 LOAD request_custom_alias 0
 RELOAD request_custom_alias
-INCMP confirm_new_alias *
+INCMP  confirm_new_alias *
--- a/services/registration/my_account_alias_swa
+++ b/services/registration/my_account_alias_swa
@@ -1,2 +1,2 @@
 Lakabu ya sasa: {{.get_current_profile_info}}
-Weka lakabu unalopendelea:
+Weka lakabu unalopendelea::
--- a/services/registration/my_balance.vis
+++ b/services/registration/my_balance.vis
@@ -1,6 +1,6 @@
 LOAD reset_incorrect 6
 LOAD check_balance 0
-CATCH api_failure flag_api_call_error 1
+CATCH api_failure  flag_api_call_error  1
 MAP check_balance
 CATCH incorrect_pin flag_incorrect_pin 1
 CATCH pin_entry flag_account_authorized 0
--- a/services/registration/new_pin.vis
+++ b/services/registration/new_pin.vis
@@ -2,5 +2,6 @@ MOUT back 0
 HALT
 INCMP _ 0
 RELOAD save_temporary_pin
-CATCH invalid_pin flag_invalid_pin 1
-INCMP confirm_pin_change *
+RELOAD verify_new_pin
+CATCH invalid_pin flag_valid_pin 0
+INCMP * confirm_pin_change
--- a/services/registration/old_pin.vis
+++ b/services/registration/old_pin.vis
@@ -4,5 +4,5 @@ HALT
 INCMP _ 0
 RELOAD authorize_account
 CATCH incorrect_pin flag_incorrect_pin 1
-CATCH invalid_pin flag_invalid_pin 1
+CATCH invalid_pin  flag_invalid_pin 1
 INCMP new_pin *
--- a/services/registration/others_pin_mismatch
+++ b/services/registration/others_pin_mismatch
@@ -0,0 +1 @@
+The PIN you have entered is not a match
--- a/services/registration/others_pin_mismatch.vis
+++ b/services/registration/others_pin_mismatch.vis
--- a/services/registration/others_pin_mismatch_swa
+++ b/services/registration/others_pin_mismatch_swa
@@ -0,0 +1 @@
+PIN uliyoweka hailingani.Jaribu tena.
--- a/services/registration/pin_management.vis
+++ b/services/registration/pin_management.vis
@@ -1,6 +1,7 @@
 LOAD set_back 6
 LOAD authorize_account 16
 LOAD reset_allow_update 4
+LOAD verify_new_pin 2
 LOAD save_temporary_pin 1
 LOAD reset_incorrect 0
 LOAD reset_invalid_pin 6
--- a/services/registration/pin_reset_mismatch
+++ b/services/registration/pin_reset_mismatch
@@ -0,0 +1 @@
+The PIN is not a match. Try again
--- a/services/registration/pin_reset_mismatch.vis
+++ b/services/registration/pin_reset_mismatch.vis
@@ -0,0 +1,6 @@
+MOUT retry 1
+MOUT quit 9
+HALT
+INCMP _ 1
+INCMP quit 9
+INCMP . *
--- a/services/registration/pin_reset_mismatch_swa
+++ b/services/registration/pin_reset_mismatch_swa
@@ -0,0 +1 @@
+PIN uliyoweka hailingani.Jaribu tena.
--- a/services/registration/pin_reset_result.vis
+++ b/services/registration/pin_reset_result.vis
@@ -1,4 +1,3 @@
-CATCH _ flag_account_authorized 0
 LOAD retrieve_blocked_number 0
 MAP retrieve_blocked_number
 LOAD reset_others_pin 6
@@ -6,4 +5,4 @@ MOUT back 0
 MOUT quit 9
 HALT
 INCMP ^ 0
-INCMP quit 9
+INCMP quit  9
--- a/services/registration/pin_reset_success.vis
+++ b/services/registration/pin_reset_success.vis
@@ -1,6 +1,6 @@
 MOUT back 0
 MOUT quit 9
 HALT
-INCMP ^ 0
+INCMP main 0
 INCMP quit 9
 INCMP . *
--- a/services/registration/pp.csv
+++ b/services/registration/pp.csv
@@ -9,7 +9,7 @@ flag,flag_account_authorized,15,this is set to allow a user access guarded nodes
 flag,flag_invalid_recipient,16,this is set when the transaction recipient is invalid
 flag,flag_invalid_recipient_with_invite,17,this is set when the transaction recipient is valid but not on the platform
 flag,flag_invalid_amount,18,this is set when the given transaction amount is invalid
-flag,flag_incorrect_pin,19,this is set when the provided PIN does not match the current account's PIN
+flag,flag_incorrect_pin,19,this is set when the provided PIN is invalid or does not match the current account's PIN
 flag,flag_valid_pin,20,this is set when the given PIN is valid
 flag,flag_allow_update,21,this is set to allow a user to update their profile data
 flag,flag_single_edit,22,this is set to allow a user to edit a single profile item such as year of birth
@@ -31,4 +31,3 @@ flag,flag_back_set,37,this is set when it is a back navigation
 flag,flag_account_blocked,38,this is set when an account has been blocked after the allowed incorrect PIN attempts have been exceeded
 flag,flag_invalid_pin,39,this is set when the given PIN is invalid(is  less than or more than 4 digits)
 flag,flag_alias_set,40,this is set when an account alias has been assigned to a user
-flag,flag_account_pin_reset,41,this is set on an account when an admin triggers a PIN reset for them
--- a/services/registration/root.vis
+++ b/services/registration/root.vis
@@ -2,14 +2,13 @@ LOAD check_blocked_status 1
 RELOAD check_blocked_status
 LOAD check_account_created 2
 RELOAD check_account_created
-CATCH self_reset_pin flag_account_pin_reset 1
 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
 RELOAD check_account_status
-CATCH api_failure flag_api_call_error 1
+CATCH api_failure flag_api_call_error  1
 CATCH account_pending flag_account_pending 1
+CATCH create_pin flag_pin_set 0
 CATCH main flag_account_success 1
 HALT
--- a/services/registration/self_reset_pin
+++ b/services/registration/self_reset_pin
@@ -1,2 +0,0 @@
-A PIN reset has been done on your account.
-Please enter a new four number PIN:
--- a/services/registration/self_reset_pin.vis
+++ b/services/registration/self_reset_pin.vis
@@ -1,6 +0,0 @@
-LOAD reset_invalid_pin 6
-HALT
-LOAD save_temporary_pin 1
-RELOAD save_temporary_pin
-CATCH invalid_pin flag_invalid_pin 1
-INCMP confirm_pin_change * 
--- a/services/registration/self_reset_pin_swa
+++ b/services/registration/self_reset_pin_swa
@@ -1,2 +0,0 @@
-Uwekaji upya wa PIN umefanyika kwenye akaunti yako.
-Tafadhali weka PIN mpya ya nambari nne:
--- a/store/db/db.go
+++ b/store/db/db.go
@@ -63,10 +63,6 @@ const (
 	DATA_INITIAL_LANGUAGE_CODE
 	//Fully qualified account alias string
 	DATA_ACCOUNT_ALIAS
-	//currently suggested alias by the api awaiting user's confirmation as accepted account alias
-	DATA_SUGGESTED_ALIAS
-	//Key used to store a value of 1 for a user to reset their own PIN once they access the menu. 
-	DATA_SELF_PIN_RESET
 )

 const (
--- a/store/log_db.go
+++ b/store/log_db.go
@@ -1,27 +0,0 @@
-package store
-
-import (
-	"context"
-
-	visedb "git.defalsify.org/vise.git/db"
-	"git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
-	storedb "git.grassecon.net/grassrootseconomics/sarafu-vise/store/db"
-)
-
-type LogDb struct {
-	visedb.Db
-}
-
-func (db *LogDb) WriteLogEntry(ctx context.Context, sessionId string, typ db.DataTyp, v []byte) error {
-	db.SetPrefix(visedb.DATATYPE_USERDATA)
-	db.SetSession(sessionId)
-	k := storedb.ToBytes(typ)
-	return db.Put(ctx, k, v)
-}
-
-func (db *LogDb) ReadLogEntry(ctx context.Context, sessionId string, typ db.DataTyp) ([]byte, error) {
-	db.SetPrefix(visedb.DATATYPE_USERDATA)
-	db.SetSession(sessionId)
-	k := storedb.ToBytes(typ)
-	return db.Get(ctx, k)
-}
--- a/testutil/engine.go
+++ b/testutil/engine.go
@@ -113,12 +113,6 @@ func TestEngine(sessionId string) (engine.Engine, func(), chan bool, *persist.Pe
 		os.Exit(1)
 	}

-	logdb, err := menuStorageService.GetLogDb(ctx, userDataStore, "test-db-logs", "user-data")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "get log db error: %v\n", err)
-		os.Exit(1)
-	}
-
 	dbResource, ok := rs.(*resource.DbResource)
 	if !ok {
 		fmt.Fprintf(os.Stderr, "dbresource cast error")
@@ -127,7 +121,6 @@ func TestEngine(sessionId string) (engine.Engine, func(), chan bool, *persist.Pe

 	lhs, err := handlers.NewLocalHandlerService(ctx, pfp, true, dbResource, cfg, rs)
 	lhs.SetDataStore(&userDataStore)
-	lhs.SetLogDb(&logdb)
 	lhs.SetPersister(pe)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, err.Error())
@@ -161,7 +154,6 @@ func TestEngine(sessionId string) (engine.Engine, func(), chan bool, *persist.Pe

 	en := lhs.GetEngine(lhs.Cfg, rs, pe)
 	cleanFn := func() {
-		logdb.Close(ctx)
 		err := en.Finish(ctx)
 		if err != nil {
 			logg.Errorf(err.Error())
Author	SHA1	Message	Date
Carlosokumu	b8cbccb113	call memory's pop to free cache's current level	2025-03-27 12:31:46 +03:00
lash	e064ec40de	Check argument count in devtools admin	2025-03-26 18:28:06 +00:00
lash	02bebe605a	Add reset tool	2025-03-26 18:17:54 +00:00
				`@@ -0,0 +1 @@`
				`Please confirm new PIN for: {{.retrieve_blocked_number}}`
				`@@ -0,0 +1 @@`
				`Tafadhali thibitisha PIN mpya ya: {{.retrieve_blocked_number}}`
				`@@ -0,0 +1 @@`
				`Please enter new PIN for: {{.retrieve_blocked_number}}`
				`@@ -0,0 +1 @@`
				`Tafadhali weka PIN mpya ya: {{.retrieve_blocked_number}}`
				`@@ -0,0 +1 @@`
				`The PIN you have entered is invalid.Please try a 4 digit number instead.`