common/db.go

@@ -32,19 +32,7 @@ const (
 	DATA_PUBLIC_KEY_REVERSE
 	DATA_ACTIVE_DECIMAL
 	DATA_ACTIVE_ADDRESS
-	// Start the sub prefix data at 256 (0x0100)
+	DATA_TRANSACTIONS
-	DATA_VOUCHER_SYMBOLS DataTyp = 256 + iota
-	DATA_VOUCHER_BALANCES
-	DATA_VOUCHER_DECIMALS
-	DATA_VOUCHER_ADDRESSES
-	DATA_TX_SENDERS
-	DATA_TX_RECIPIENTS
-	DATA_TX_VALUES
-	DATA_TX_ADDRESSES
-	DATA_TX_HASHES
-	DATA_TX_DATES
-	DATA_TX_SYMBOLS
-	DATA_TX_DECIMALS
 )
 
 var (
@@ -81,10 +69,3 @@ func StringToDataTyp(str string) (DataTyp, error) {
 		return 0, errors.New("invalid DataTyp string")
 	}
 }
-
-// ToBytes converts DataTyp or int to a byte slice
-func ToBytes[T ~uint16 | int](value T) []byte {
-	bytes := make([]byte, 2)
-	binary.BigEndian.PutUint16(bytes, uint16(value))
-	return bytes
-}

common/transfer_statements.go

@@ -57,25 +57,25 @@ func ProcessTransfers(transfers []dataserviceapi.Last10TxResponse) TransferMetad
 // GetTransferData retrieves and matches transfer data
 // returns a formatted string of the full transaction/statement
 func GetTransferData(ctx context.Context, db storage.PrefixDb, publicKey string, index int) (string, error) {
-	keys := []DataTyp{DATA_TX_SENDERS, DATA_TX_RECIPIENTS, DATA_TX_VALUES, DATA_TX_ADDRESSES, DATA_TX_HASHES, DATA_TX_DATES, DATA_TX_SYMBOLS}
+	keys := []string{"txfrom", "txto", "txval", "txaddr", "txhash", "txdate", "txsym"}
-	data := make(map[DataTyp]string)
+	data := make(map[string]string)
 
 	for _, key := range keys {
-		value, err := db.Get(ctx, ToBytes(key))
+		value, err := db.Get(ctx, []byte(key))
 		if err != nil {
-			return "", fmt.Errorf("failed to get %s: %v", ToBytes(key), err)
+			return "", fmt.Errorf("failed to get %s: %v", key, err)
 		}
 		data[key] = string(value)
 	}
 
 	// Split the data
-	senders := strings.Split(string(data[DATA_TX_SENDERS]), "\n")
+	senders := strings.Split(string(data["txfrom"]), "\n")
-	recipients := strings.Split(string(data[DATA_TX_RECIPIENTS]), "\n")
+	recipients := strings.Split(string(data["txto"]), "\n")
-	values := strings.Split(string(data[DATA_TX_VALUES]), "\n")
+	values := strings.Split(string(data["txval"]), "\n")
-	addresses := strings.Split(string(data[DATA_TX_ADDRESSES]), "\n")
+	addresses := strings.Split(string(data["txaddr"]), "\n")
-	hashes := strings.Split(string(data[DATA_TX_HASHES]), "\n")
+	hashes := strings.Split(string(data["txhash"]), "\n")
-	dates := strings.Split(string(data[DATA_TX_DATES]), "\n")
+	dates := strings.Split(string(data["txdate"]), "\n")
-	syms := strings.Split(string(data[DATA_TX_SYMBOLS]), "\n")
+	syms := strings.Split(string(data["txsym"]), "\n")
 
 	// Check if index is within range
 	if index < 1 || index > len(senders) {

common/vouchers.go

@@ -64,23 +64,22 @@ func ScaleDownBalance(balance, decimals string) string {
 
 // GetVoucherData retrieves and matches voucher data
 func GetVoucherData(ctx context.Context, db storage.PrefixDb, input string) (*dataserviceapi.TokenHoldings, error) {
-	keys := []DataTyp{DATA_VOUCHER_SYMBOLS, DATA_VOUCHER_BALANCES, DATA_VOUCHER_DECIMALS, DATA_VOUCHER_ADDRESSES}
+	keys := []string{"sym", "bal", "deci", "addr"}
-	data := make(map[DataTyp]string)
+	data := make(map[string]string)
 
 	for _, key := range keys {
-		value, err := db.Get(ctx, ToBytes(key))
+		value, err := db.Get(ctx, []byte(key))
 		if err != nil {
-			return nil, fmt.Errorf("failed to get %s: %v", ToBytes(key), err)
+			return nil, fmt.Errorf("failed to get %s: %v", key, err)
 		}
 		data[key] = string(value)
 	}
 
 	symbol, balance, decimal, address := MatchVoucher(input,
-		data[DATA_VOUCHER_SYMBOLS],
+		data["sym"],
-		data[DATA_VOUCHER_BALANCES],
+		data["bal"],
-		data[DATA_VOUCHER_DECIMALS],
+		data["deci"],
-		data[DATA_VOUCHER_ADDRESSES],
+		data["addr"])
-	)
 
 	if symbol == "" {
 		return nil, nil

common/vouchers_test.go

@@ -8,9 +8,8 @@ import (
 	"github.com/alecthomas/assert/v2"
 	"github.com/stretchr/testify/require"
 
-	visedb "git.defalsify.org/vise.git/db"
-	memdb "git.defalsify.org/vise.git/db/mem"
 	"git.grassecon.net/urdt/ussd/internal/storage"
+	memdb "git.defalsify.org/vise.git/db/mem"
 	dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
 )
 
@@ -84,21 +83,19 @@ func TestGetVoucherData(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
+	spdb := storage.NewSubPrefixDb(db, []byte("vouchers"))
-	prefix := ToBytes(visedb.DATATYPE_USERDATA)
-	spdb := storage.NewSubPrefixDb(db, prefix)
 
 	// Test voucher data
-	mockData := map[DataTyp][]byte{
+	mockData := map[string][]byte{
-		DATA_VOUCHER_SYMBOLS:   []byte("1:SRF\n2:MILO"),
+		"sym":  []byte("1:SRF\n2:MILO"),
-		DATA_VOUCHER_BALANCES:  []byte("1:100\n2:200"),
+		"bal":  []byte("1:100\n2:200"),
-		DATA_VOUCHER_DECIMALS:  []byte("1:6\n2:4"),
+		"deci": []byte("1:6\n2:4"),
-		DATA_VOUCHER_ADDRESSES: []byte("1:0xd4c288865Ce\n2:0x41c188d63Qa"),
+		"addr": []byte("1:0xd4c288865Ce\n2:0x41c188d63Qa"),
 	}
 
 	// Put the data
 	for key, value := range mockData {
-		err = spdb.Put(ctx, []byte(ToBytes(key)), []byte(value))
+		err = spdb.Put(ctx, []byte(key), []byte(value))
 		if err != nil {
 			t.Fatal(err)
 		}

internal/handlers/ussd/menuhandler.go

@@ -85,10 +85,8 @@ func NewHandlers(appFlags *asm.FlagParser, userdataStore db.Db, adminstore *util
 	userDb := &common.UserDataStore{
 		Db: userdataStore,
 	}
-
+	// Instantiate the SubPrefixDb with "vouchers" prefix
-	// Instantiate the SubPrefixDb with "DATATYPE_USERDATA" prefix
+	prefixDb := storage.NewSubPrefixDb(userdataStore, []byte("vouchers"))
-	prefix := common.ToBytes(db.DATATYPE_USERDATA)
-	prefixDb := storage.NewSubPrefixDb(userdataStore, prefix)
 
 	h := &Handlers{
 		userdataStore:  userDb,
@@ -1578,15 +1576,15 @@ func (h *Handlers) CheckVouchers(ctx context.Context, sym string, input []byte)
 	data := common.ProcessVouchers(vouchersResp)
 
 	// Store all voucher data
-	dataMap := map[common.DataTyp]string{
+	dataMap := map[string]string{
-		common.DATA_VOUCHER_SYMBOLS:   data.Symbols,
+		"sym":  data.Symbols,
-		common.DATA_VOUCHER_BALANCES:  data.Balances,
+		"bal":  data.Balances,
-		common.DATA_VOUCHER_DECIMALS:  data.Decimals,
+		"deci": data.Decimals,
-		common.DATA_VOUCHER_ADDRESSES: data.Addresses,
+		"addr": data.Addresses,
 	}
 
 	for key, value := range dataMap {
-		if err := h.prefixDb.Put(ctx, []byte(common.ToBytes(key)), []byte(value)); err != nil {
+		if err := h.prefixDb.Put(ctx, []byte(key), []byte(value)); err != nil {
 			return res, nil
 		}
 	}
@@ -1599,7 +1597,7 @@ func (h *Handlers) GetVoucherList(ctx context.Context, sym string, input []byte)
 	var res resource.Result
 
 	// Read vouchers from the store
-	voucherData, err := h.prefixDb.Get(ctx, common.ToBytes(common.DATA_VOUCHER_SYMBOLS))
+	voucherData, err := h.prefixDb.Get(ctx, []byte("sym"))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Failed to read the voucherData from prefixDb", "error", err)
 		return res, err
@@ -1745,19 +1743,19 @@ func (h *Handlers) CheckTransactions(ctx context.Context, sym string, input []by
 	data := common.ProcessTransfers(transactionsResp)
 
 	// Store all transaction data
-	dataMap := map[common.DataTyp]string{
+	dataMap := map[string]string{
-		common.DATA_TX_SENDERS:    data.Senders,
+		"txfrom": data.Senders,
-		common.DATA_TX_RECIPIENTS: data.Recipients,
+		"txto":   data.Recipients,
-		common.DATA_TX_VALUES:     data.TransferValues,
+		"txval":  data.TransferValues,
-		common.DATA_TX_ADDRESSES:  data.Addresses,
+		"txaddr": data.Addresses,
-		common.DATA_TX_HASHES:     data.TxHashes,
+		"txhash": data.TxHashes,
-		common.DATA_TX_DATES:      data.Dates,
+		"txdate": data.Dates,
-		common.DATA_TX_SYMBOLS:    data.Symbols,
+		"txsym":  data.Symbols,
-		common.DATA_TX_DECIMALS:   data.Decimals,
+		"txdeci": data.Decimals,
 	}
 
 	for key, value := range dataMap {
-		if err := h.prefixDb.Put(ctx, []byte(common.ToBytes(key)), []byte(value)); err != nil {
+		if err := h.prefixDb.Put(ctx, []byte(key), []byte(value)); err != nil {
 			logg.ErrorCtxf(ctx, "failed to write to prefixDb", "error", err)
 			return res, err
 		}
@@ -1783,22 +1781,22 @@ func (h *Handlers) GetTransactionsList(ctx context.Context, sym string, input []
 	}
 
 	// Read transactions from the store and format them
-	TransactionSenders, err := h.prefixDb.Get(ctx, common.ToBytes(common.DATA_TX_SENDERS))
+	TransactionSenders, err := h.prefixDb.Get(ctx, []byte("txfrom"))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Failed to read the TransactionSenders from prefixDb", "error", err)
 		return res, err
 	}
-	TransactionSyms, err := h.prefixDb.Get(ctx, common.ToBytes(common.DATA_TX_SYMBOLS))
+	TransactionSyms, err := h.prefixDb.Get(ctx, []byte("txsym"))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Failed to read the TransactionSyms from prefixDb", "error", err)
 		return res, err
 	}
-	TransactionValues, err := h.prefixDb.Get(ctx, common.ToBytes(common.DATA_TX_VALUES))
+	TransactionValues, err := h.prefixDb.Get(ctx, []byte("txval"))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Failed to read the TransactionValues from prefixDb", "error", err)
 		return res, err
 	}
-	TransactionDates, err := h.prefixDb.Get(ctx, common.ToBytes(common.DATA_TX_DATES))
+	TransactionDates, err := h.prefixDb.Get(ctx, []byte("txdate"))
 	if err != nil {
 		logg.ErrorCtxf(ctx, "Failed to read the TransactionDates from prefixDb", "error", err)
 		return res, err

internal/handlers/ussd/menuhandler_test.go

@@ -22,7 +22,6 @@ import (
 	testdataloader "github.com/peteole/testdata-loader"
 	"github.com/stretchr/testify/require"
 
-	visedb "git.defalsify.org/vise.git/db"
 	memdb "git.defalsify.org/vise.git/db/mem"
 	dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
 )
@@ -57,8 +56,7 @@ func InitializeTestSubPrefixDb(t *testing.T, ctx context.Context) *storage.SubPr
 	if err != nil {
 		t.Fatal(err)
 	}
-	prefix := common.ToBytes(visedb.DATATYPE_USERDATA)
+	spdb := storage.NewSubPrefixDb(db, []byte("vouchers"))
-	spdb := storage.NewSubPrefixDb(db, prefix)
 
 	return spdb
 }
@@ -1939,7 +1937,7 @@ func TestCheckVouchers(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Read voucher sym data from the store
-	voucherData, err := spdb.Get(ctx, common.ToBytes(common.DATA_VOUCHER_SYMBOLS))
+	voucherData, err := spdb.Get(ctx, []byte("sym"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1963,7 +1961,7 @@ func TestGetVoucherList(t *testing.T) {
 	expectedSym := []byte("1:SRF\n2:MILO")
 
 	// Put voucher sym data from the store
-	err := spdb.Put(ctx, common.ToBytes(common.DATA_VOUCHER_SYMBOLS), expectedSym)
+	err := spdb.Put(ctx, []byte("sym"), expectedSym)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -1993,16 +1991,16 @@ func TestViewVoucher(t *testing.T) {
 	}
 
 	// Define mock voucher data
-	mockData := map[common.DataTyp][]byte{
+	mockData := map[string][]byte{
-		common.DATA_VOUCHER_SYMBOLS:   []byte("1:SRF\n2:MILO"),
+		"sym":  []byte("1:SRF\n2:MILO"),
-		common.DATA_VOUCHER_BALANCES:  []byte("1:100\n2:200"),
+		"bal":  []byte("1:100\n2:200"),
-		common.DATA_VOUCHER_DECIMALS:  []byte("1:6\n2:4"),
+		"deci": []byte("1:6\n2:4"),
-		common.DATA_VOUCHER_ADDRESSES: []byte("1:0xd4c288865Ce\n2:0x41c188d63Qa"),
+		"addr": []byte("1:0xd4c288865Ce\n2:0x41c188d63Qa"),
 	}
 
 	// Put the data
 	for key, value := range mockData {
-		err = spdb.Put(ctx, []byte(common.ToBytes(key)), []byte(value))
+		err = spdb.Put(ctx, []byte(key), []byte(value))
 		if err != nil {
 			t.Fatal(err)
 		}

internal/storage/db.go

@@ -6,6 +6,10 @@ import (
 	"git.defalsify.org/vise.git/db"
 )
 
+const (
+	DATATYPE_USERSUB = 64
+)
+
 // PrefixDb interface abstracts the database operations.
 type PrefixDb interface {
 	Get(ctx context.Context, key []byte) ([]byte, error)
@@ -31,13 +35,13 @@ func (s *SubPrefixDb) toKey(k []byte) []byte {
 }
 
 func (s *SubPrefixDb) Get(ctx context.Context, key []byte) ([]byte, error) {
-	s.store.SetPrefix(db.DATATYPE_USERDATA)
+	s.store.SetPrefix(DATATYPE_USERSUB)
 	key = s.toKey(key)
 	return s.store.Get(ctx, key)
 }
 
 func (s *SubPrefixDb) Put(ctx context.Context, key []byte, val []byte) error {
-	s.store.SetPrefix(db.DATATYPE_USERDATA)
+	s.store.SetPrefix(DATATYPE_USERSUB)
 	key = s.toKey(key)
 	return s.store.Put(ctx, key, val)
 }