grassrootseconomics/sarafu-api
7
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

dev-api-aliases #5

Merged
lash merged 6 commits from dev-api-aliases into master 2025-01-21 07:17:09 +01:00
Conversation 0 Commits 6 Files Changed 3 +170 -110
3 changed files with 170 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

257
dev/api.go
View File

@ -12,65 +12,67 @@ import (
"strings"
"time"
"github.com/gofrs/uuid"
"git.defalsify.org/vise.git/logging"
"git.defalsify.org/vise.git/db"
"git.grassecon.net/grassrootseconomics/sarafu-api/models"
"git.grassecon.net/grassrootseconomics/sarafu-api/event"
"git.defalsify.org/vise.git/logging"
"git.grassecon.net/grassrootseconomics/common/phone"
"git.grassecon.net/grassrootseconomics/sarafu-api/event"
"git.grassecon.net/grassrootseconomics/sarafu-api/models"
"git.grassecon.net/grassrootseconomics/visedriver/storage"
"github.com/gofrs/uuid"
dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
)
var (
logg = logging.NewVanilla().WithDomain("sarafu-api.devapi")
aliasRegex = regexp.MustCompile("^\\+?[a-zA-Z0-9\\-_]+$")
logg = logging.NewVanilla().WithDomain("sarafu-api.devapi")
aliasRegex = regexp.MustCompile("^\\+?[a-zA-Z0-9\\-_]+$")
searchDomain = ".sarafu.local"
)
const (
pubKeyLen int = 20
hashLen int = 32
defaultDecimals = 6
zeroAddress string = "0x0000000000000000000000000000000000000000"
pubKeyLen int = 20
hashLen int = 32
defaultDecimals = 6
zeroAddress string = "0x0000000000000000000000000000000000000000"
defaultVoucherBalance float64 = 500.00
)
type Tx struct {
Track string `json: "track"`
Hsh string `json:"hash"`
To string `json:"to"`
From string `json: "from"`
Voucher string `json: "voucher"`
Value int `json: "value"`
When time.Time `json: "when"`
Track string `json: "track"`
Hsh string `json:"hash"`
To string `json:"to"`
From string `json: "from"`
Voucher string `json: "voucher"`
Value int `json: "value"`
When time.Time `json: "when"`
}
func (t *Tx) ToTransferEvent() event.EventTokenTransfer {
return event.EventTokenTransfer{
To: t.To,
Value: t.Value,
To: t.To,
Value: t.Value,
VoucherAddress: t.Voucher,
TxHash: t.Hsh,
From: t.From,
TxHash: t.Hsh,
From: t.From,
}
}
func (t *Tx) ToMintEvent() event.EventTokenMint {
return event.EventTokenMint{
To: t.To,
Value: t.Value,
To: t.To,
Value: t.Value,
VoucherAddress: t.Voucher,
TxHash: t.Hsh,
TxHash: t.Hsh,
}
}
type Account struct {
Track string `json: "track"`
Address string `json: "address"`
Nonce int `json: "nonce"`
DefaultVoucher string `json: "defaultVoucher"`
Balances map[string]int `json: "balances"`
Alias string
Txs []string `json: "txs"`
Track string `json: "track"`
Address string `json: "address"`
Nonce int `json: "nonce"`
DefaultVoucher string `json: "defaultVoucher"`
Balances map[string]int `json: "balances"`
Alias string
Txs []string `json: "txs"`
}
func (a *Account) ToRegistrationEvent() event.EventCustodialRegistration {
@ -80,45 +82,44 @@ func (a *Account) ToRegistrationEvent() event.EventCustodialRegistration {
}
type Voucher struct {
Name string `json: "name"`
Address string `json: "address"`
Symbol string `json: "symbol"`
Decimals int `json: "decimals"`
Sink string `json: "sink"`
Name string `json: "name"`
Address string `json: "address"`
Symbol string `json: "symbol"`
Decimals int `json: "decimals"`
Sink string `json: "sink"`
Commodity string `json: "commodity"`
Location string `json: "location"`
Location string `json: "location"`
}
type DevAccountService struct {
db db.Db
accounts map[string]Account
accountsTrack map[string]string
accountsAlias map[string]string
vouchers map[string]Voucher
vouchersAddress map[string]string
txs map[string]Tx
txsTrack map[string]string
toAutoCreate bool
autoVouchers []string
db db.Db
accounts map[string]Account
accountsTrack map[string]string
accountsAlias map[string]string
vouchers map[string]Voucher
vouchersAddress map[string]string
txs map[string]Tx
txsTrack map[string]string
toAutoCreate bool
autoVouchers []string
autoVoucherValue map[string]int
defaultAccount string
emitterFunc event.EmitterFunc
pfx []byte
// accountsSession map[string]string
defaultAccount string
emitterFunc event.EmitterFunc
pfx []byte
lash commented 2025-01-20 15:45:04 +01:00
Review
Copy Link

remove commentedp lease

remove commentedp lease
}
func NewDevAccountService(ctx context.Context, ss storage.StorageService) *DevAccountService {
svc := &DevAccountService{
accounts: make(map[string]Account),
accountsTrack: make(map[string]string),
accountsAlias: make(map[string]string),
vouchers: make(map[string]Voucher),
vouchersAddress: make(map[string]string),
txs: make(map[string]Tx),
txsTrack: make(map[string]string),
accounts: make(map[string]Account),
accountsTrack: make(map[string]string),
accountsAlias: make(map[string]string),
vouchers: make(map[string]Voucher),
vouchersAddress: make(map[string]string),
txs: make(map[string]Tx),
txsTrack: make(map[string]string),
autoVoucherValue: make(map[string]int),
defaultAccount: zeroAddress,
pfx: []byte("__"),
defaultAccount: zeroAddress,
pfx: []byte("__"),
}
if ss != nil {
var err error
@ -151,7 +152,7 @@ func (das *DevAccountService) WithPrefix(pfx []byte) *DevAccountService {
}
func (das *DevAccountService) prefixKeyFor(k string, v string) []byte {
return append(das.pfx, []byte(k + "_" + v)...)
return append(das.pfx, []byte(k+"_"+v)...)
}
func (das *DevAccountService) loadAccount(ctx context.Context, pubKey string, v []byte) error {
@ -183,6 +184,15 @@ func (das *DevAccountService) loadTx(ctx context.Context, hsh string, v []byte)
return nil
}
func (das *DevAccountService) loadAlias(ctx context.Context, alias string, key []byte) error {
result, err := das.db.Get(ctx, key)
if err != nil {
return err
}
das.accountsAlias[alias] = strings.ReplaceAll(string(result), `"`, "")
return nil
}
func (das *DevAccountService) loadItem(ctx context.Context, k []byte, v []byte) error {
var err error
s := string(k)
@ -194,6 +204,8 @@ func (das *DevAccountService) loadItem(ctx context.Context, k []byte, v []byte)
err = das.loadAccount(ctx, ss[1], v)
} else if ss[0] == "tx" {
err = das.loadTx(ctx, ss[1], v)
} else if ss[0] == "alias" {
err = das.loadAlias(ctx, ss[1], k)
} else {
logg.ErrorCtxf(ctx, "unknown double underscore key", "key", ss[0])
}
@ -225,7 +237,7 @@ func (das *DevAccountService) loadAll(ctx context.Context) error {
}
func (das *DevAccountService) indexAll(ctx context.Context) error {
for k, v := range(das.txs) {
for k, v := range das.txs {
acc := das.accounts[v.From]
acc.Txs = append(acc.Txs, k)
logg.TraceCtxf(ctx, "add tx to sender index", "from", v.From, "tx", k)
@ -265,8 +277,8 @@ func (das *DevAccountService) AddVoucher(ctx context.Context, symbol string) err
z := h.Sum(nil)
address := fmt.Sprintf("0x%x", z)
das.vouchers[symbol] = Voucher{
Name: symbol,
Symbol: symbol,
Name: symbol,
Symbol: symbol,
Address: address,
}
das.vouchersAddress[address] = symbol
@ -288,14 +300,14 @@ func (das *DevAccountService) CheckBalance(ctx context.Context, publicKey string
if !ok {
return nil, fmt.Errorf("balance not found for default token %s pubkey %v", acc.DefaultVoucher, publicKey)
}
return &models.BalanceResult {
return &models.BalanceResult{
Balance: strconv.Itoa(bal),
Nonce: json.Number(strconv.Itoa(acc.Nonce)),
Nonce: json.Number(strconv.Itoa(acc.Nonce)),
}, nil
}
func (das *DevAccountService) balanceAuto(ctx context.Context, pubKey string) error {
for _, v := range(das.autoVouchers) {
for _, v := range das.autoVouchers {
voucher, ok := das.vouchers[v]
if !ok {
return fmt.Errorf("balance auto voucher set but not resolved: %s", v)
@ -312,6 +324,10 @@ func (das *DevAccountService) balanceAuto(ctx context.Context, pubKey string) er
return nil
}
func (das *DevAccountService) GetAliases(ctx context.Context) map[string]string {
return das.accountsAlias
}
func (das *DevAccountService) saveAccount(ctx context.Context, acc Account) error {
if das.db == nil {
return nil
@ -326,6 +342,27 @@ func (das *DevAccountService) saveAccount(ctx context.Context, acc Account) erro
return das.db.Put(ctx, []byte(k), v)
}
func (das *DevAccountService) saveAlias(ctx context.Context, alias map[string]string) error {
if das.db == nil {
return fmt.Errorf("Db cannot be nil")
}
sessionId, ok := ctx.Value("SessionId").(string)
if !ok {
return fmt.Errorf("unresolved session id")
}
for k, v := range alias {
k_ := das.prefixKeyFor("alias", k)
v_, err := json.Marshal(v)
if err != nil {
return err
}
das.db.SetSession(sessionId)
das.db.SetPrefix(db.DATATYPE_USERDATA)
return das.db.Put(ctx, []byte(k_), v_)
}
return nil
}
func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.AccountResult, error) {
var b [pubKeyLen]byte
uid, err := uuid.NewV4()
@ -341,7 +378,7 @@ func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.Accoun
}
pubKey := fmt.Sprintf("0x%x", b)
acc := Account{
Track: uid.String(),
Track: uid.String(),
Address: pubKey,
}
@ -363,7 +400,7 @@ func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.Accoun
if das.emitterFunc != nil {
msg := event.Msg{
Typ: event.EventRegistrationTag,
Typ: event.EventRegistrationTag,
Item: acc,
}
err = das.emitterFunc(ctx, msg)
@ -374,7 +411,7 @@ func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.Accoun
logg.TraceCtxf(ctx, "account created", "account", acc)
return &models.AccountResult{
PublicKey: pubKey,
PublicKey: pubKey,
TrackingId: uid.String(),
}, nil
}
@ -392,22 +429,20 @@ func (das *DevAccountService) TrackAccountStatus(ctx context.Context, publicKey
func (das *DevAccountService) FetchVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) {
var holdings []dataserviceapi.TokenHoldings
acc, ok := das.accounts[publicKey]
_, ok := das.accounts[publicKey]
if !ok {
return nil, fmt.Errorf("account not found (publickey): %v", publicKey)
}
for k, v := range(acc.Balances) {
voucher, ok := das.vouchers[k]
if !ok {
return nil, fmt.Errorf("voucher has balance but object not found: %v", k)
}
//TODO: Iterate over the account acc.Balances object
for _, voucher := range das.vouchers {
holdings = append(holdings, dataserviceapi.TokenHoldings{
ContractAddress: voucher.Address,
TokenSymbol: voucher.Symbol,
TokenDecimals: strconv.Itoa(voucher.Decimals),
Balance: strconv.Itoa(v),
TokenSymbol: voucher.Symbol,
TokenDecimals: strconv.Itoa(voucher.Decimals),
Balance: strconv.Itoa(int(defaultVoucherBalance)),
})
}
return holdings, nil
}
@ -417,24 +452,24 @@ func (das *DevAccountService) FetchTransactions(ctx context.Context, publicKey s
if !ok {
return nil, fmt.Errorf("account not found (publickey): %v", publicKey)
}
for i, v := range(acc.Txs) {
for i, v := range acc.Txs {
mytx := das.txs[v]
if i == 10 {
break
break
}
voucher, ok := das.vouchers[mytx.Voucher]
if !ok {
return nil, fmt.Errorf("voucher %s in tx list but not found in voucher list", mytx.Voucher)
}
lasttx = append(lasttx, dataserviceapi.Last10TxResponse{
Sender: mytx.From,
Recipient: mytx.To,
TransferValue: strconv.Itoa(mytx.Value),
Sender: mytx.From,
Recipient: mytx.To,
TransferValue: strconv.Itoa(mytx.Value),
ContractAddress: voucher.Address,
TxHash: mytx.Hsh,
DateBlock: mytx.When,
TokenSymbol: voucher.Symbol,
TokenDecimals: strconv.Itoa(voucher.Decimals),
TxHash: mytx.Hsh,
DateBlock: mytx.When,
TokenSymbol: voucher.Symbol,
TokenDecimals: strconv.Itoa(voucher.Decimals),
})
}
return lasttx, nil
@ -450,13 +485,12 @@ func (das *DevAccountService) VoucherData(ctx context.Context, address string) (
return nil, fmt.Errorf("voucher address %v found but does not resolve", address)
}
return &models.VoucherDataResult{
TokenName: voucher.Name,
TokenSymbol: voucher.Symbol,
TokenDecimals: voucher.Decimals,
SinkAddress: voucher.Sink,
TokenName: voucher.Name,
TokenSymbol: voucher.Symbol,
TokenDecimals: voucher.Decimals,
SinkAddress: voucher.Sink,
TokenCommodity: voucher.Commodity,
TokenLocation: voucher.Location,
TokenLocation: voucher.Location,
}, nil
}
@ -481,12 +515,12 @@ func (das *DevAccountService) TokenTransfer(ctx context.Context, amount, from, t
}
accFrom, ok := das.accounts[from]
if !ok {
return nil, fmt.Errorf("sender account %v not found", from)
return nil, fmt.Errorf("sender account %v not found", from)
}
accTo, ok := das.accounts[to]
if !ok {
if !das.toAutoCreate {
return nil, fmt.Errorf("recipient account %v not found, and not creating", from)
return nil, fmt.Errorf("recipient account %v not found, and not creating", from)
}
}
@ -512,13 +546,13 @@ func (das *DevAccountService) TokenTransfer(ctx context.Context, amount, from, t
}
hsh := fmt.Sprintf("0x%x", b)
mytx := Tx{
Hsh: hsh,
To: accTo.Address,
From: accFrom.Address,
Hsh: hsh,
To: accTo.Address,
From: accFrom.Address,
Voucher: voucher.Symbol,
Value: value,
Track: uid.String(),
When: time.Now(),
Value: value,
Track: uid.String(),
When: time.Now(),
}
err = das.saveTokenTransfer(ctx, mytx)
if err != nil {
@ -527,7 +561,7 @@ func (das *DevAccountService) TokenTransfer(ctx context.Context, amount, from, t
das.txs[hsh] = mytx
if das.emitterFunc != nil {
msg := event.Msg{
Typ: event.EventTokenTransferTag,
Typ: event.EventTokenTransferTag,
Item: mytx,
}
err = das.emitterFunc(ctx, msg)
@ -568,12 +602,22 @@ func (das *DevAccountService) applyPhoneAlias(ctx context.Context, publicKey str
func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string, hint string) (*models.RequestAliasResult, error) {
var alias string
uid, err := uuid.NewV4()
if !aliasRegex.MatchString(hint) {
return nil, fmt.Errorf("alias hint does not match: %s", publicKey)
}
acc, ok := das.accounts[publicKey]
if !ok {
return nil, fmt.Errorf("address %s not found", publicKey)
//Handle accounts created via the api
acc = Account{
Track: uid.String(),
Address: publicKey,
}
err = das.saveAccount(ctx, acc)
if err != nil {
return nil, err
}
das.accounts[publicKey] = acc
}
alias = hint
isPhone, err := das.applyPhoneAlias(ctx, publicKey, alias)
@ -592,7 +636,12 @@ func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string
alias += "x"
}
acc.Alias = alias
alias = alias + searchDomain
das.accountsAlias[alias] = publicKey
err := das.saveAlias(ctx, map[string]string{alias: publicKey})
if err != nil {
return nil, fmt.Errorf("Failed to save the account alias with error: %s", err.Error())
}
}
logg.DebugCtxf(ctx, "set alias", "addr", publicKey, "alias", alias)
return &models.RequestAliasResult{

10
dev/api_test.go
View File

@ -9,6 +9,7 @@ import (
func TestApiRequestAlias(t *testing.T) {
ctx := context.Background()
ctx = context.WithValue(ctx, "SessionId", "+25471234565")
storageService := mocks.NewMemStorageService(ctx)
svc := NewDevAccountService(ctx, storageService)
ra, err := svc.CreateAccount(ctx)
@ -16,10 +17,10 @@ func TestApiRequestAlias(t *testing.T) {
t.Fatal(err)
}
addr := ra.PublicKey
_, err = svc.RequestAlias(ctx, addr, "+254f00")
if err == nil {
t.Fatalf("expected error")
t.Fatalf("expected error")
}
alias := "+254712345678"
rb, err := svc.RequestAlias(ctx, addr, alias)
@ -39,6 +40,7 @@ func TestApiRequestAlias(t *testing.T) {
if err != nil {
t.Fatal(err)
}
alias = "foo.sarafu.local"
if rb.Alias != alias {
t.Fatalf("expected '%s', got '%s'", alias, rb.Alias)
}
@ -56,12 +58,12 @@ func TestApiRequestAlias(t *testing.T) {
t.Fatal(err)
}
addr = ra.PublicKey
alias = "foox"
rb, err = svc.RequestAlias(ctx, addr, alias)
if err != nil {
t.Fatal(err)
}
alias = "foox"
alias = "foox.sarafu.local"
if rb.Alias != alias {
t.Fatalf("expected '%s', got '%s'", alias, rb.Alias)
}

13
remote/http/service.go
View File

@ -3,20 +3,26 @@ package http
import (
"bytes"
"context"
"fmt"
"encoding/json"
"errors"
"io"
"log"
"net/http"
"net/url"
"regexp"
"git.grassecon.net/grassrootseconomics/sarafu-api/config"
"git.grassecon.net/grassrootseconomics/sarafu-api/dev"
"git.grassecon.net/grassrootseconomics/sarafu-api/models"
"git.grassecon.net/grassrootseconomics/visedriver/testutil/mocks"
"github.com/grassrootseconomics/eth-custodial/pkg/api"
dataserviceapi "github.com/grassrootseconomics/ussd-data-service/pkg/api"
)
var (
aliasRegex = regexp.MustCompile("^\\+?[a-zA-Z0-9\\-_]+$")
)
type HTTPAccountService struct {
}
@ -220,8 +226,11 @@ func (as *HTTPAccountService) CheckAliasAddress(ctx context.Context, alias strin
return &r, err
}
// TODO: Use actual custodial api to request available alias
func (as *HTTPAccountService) RequestAlias(ctx context.Context, publicKey string, hint string) (*models.RequestAliasResult, error) {
lash commented 2025-01-20 15:52:31 +01:00
Review
Copy Link

Can't we just point this to devapi.RequestAlias?

Can't we just point this to devapi.RequestAlias?
carlos commented 2025-01-20 18:19:48 +01:00
Review
Copy Link

@lash Nice catch.Actually that brings up an idea,could we use the same implementation of the devapi to resolve the alias' address given that the api always returns the same address?

@lash Nice catch.Actually that brings up an idea,could we use the same implementation of the devapi to resolve the alias' address given that the api always returns the same address?
lash commented 2025-01-20 18:30:29 +01:00
Review
Copy Link

yes for sure, while we wait or the api implementation.

yes for sure, while we wait or the api implementation.
👍 1
return nil, fmt.Errorf("not yet implemented")
storageService := mocks.NewMemStorageService(ctx)
svc := dev.NewDevAccountService(ctx, storageService)
return svc.RequestAlias(ctx, publicKey, hint)
}
// TODO: remove eth-custodial api dependency