From 3473a4413b4dd1328e2bfdc5145ba8e44ceb9365 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Wed, 5 Mar 2025 16:40:55 +0300 Subject: [PATCH 01/22] add pool deposit,swap and quote endpoints --- config/config.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/config/config.go b/config/config.go index 6ebb5bc..c9f323e 100644 --- a/config/config.go +++ b/config/config.go @@ -15,7 +15,10 @@ const ( voucherHoldingsPathPrefix = "/api/v1/holdings" voucherTransfersPathPrefix = "/api/v1/transfers/last10" voucherDataPathPrefix = "/api/v1/token" - AliasPrefix = "api/v1/alias" + aliasPrefix = "api/v1/alias" + poolDepositPrefix = "/api/v2/pool/deposit" + poolSwapQoutePrefix = "/api/v2/pool/quote" + poolSwapPrefix = "/api/v2/pool/swap" ) var ( @@ -34,6 +37,9 @@ var ( VoucherTransfersURL string VoucherDataURL string CheckAliasURL string + PoolDepositURL string + PoolSwapQuoteURL string + PoolSwapURL string ) func setBase() error { @@ -68,6 +74,10 @@ func LoadConfig() error { VoucherHoldingsURL, _ = url.JoinPath(dataURLBase, voucherHoldingsPathPrefix) VoucherTransfersURL, _ = url.JoinPath(dataURLBase, voucherTransfersPathPrefix) VoucherDataURL, _ = url.JoinPath(dataURLBase, voucherDataPathPrefix) - CheckAliasURL, _ = url.JoinPath(dataURLBase, AliasPrefix) + CheckAliasURL, _ = url.JoinPath(dataURLBase, aliasPrefix) + PoolDepositURL, _ = url.JoinPath(custodialURLBase, poolDepositPrefix) + PoolSwapQuoteURL, _ = url.JoinPath(custodialURLBase, poolSwapQoutePrefix) + PoolSwapURL, _ = url.JoinPath(custodialURLBase, poolSwapPrefix) + return nil } From a1fe416f51da814a5644706d266319373304985d Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Wed, 5 Mar 2025 16:41:54 +0300 Subject: [PATCH 02/22] implement pool deposit,swap and quote endpoints --- remote/http/service.go | 80 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/remote/http/service.go b/remote/http/service.go index aca8ae0..86a856a 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -239,6 +239,86 @@ func resolveAliasAddress(ctx context.Context, alias string) (*models.AliasAddres return &r, err } +func (as *HTTPAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { + var r models.PoolDepositResult + + //pool deposit payload + payload := map[string]string{ + "amount": amount, + "from": from, + "poolAddress": poolAddress, + "tokenAddress": tokenAddress, + } + + payloadBytes, err := json.Marshal(payload) + if err != nil { + return nil, err + } + req, err := http.NewRequest("POST", config.TokenTransferURL, bytes.NewBuffer(payloadBytes)) + if err != nil { + return nil, err + } + _, err = doRequest(ctx, req, &r) + if err != nil { + return nil, err + } + return &r, nil +} + +func (as *HTTPAccountService) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) { + var r models.PoolSwapQuoteResult + + //pool swap quote payload + payload := map[string]string{ + "amount": amount, + "from": from, + "fromTokenAddress": fromTokenAddress, + "poolAddress": poolAddress, + "toTokenAddress": toTokenAddress, + } + + payloadBytes, err := json.Marshal(payload) + if err != nil { + return nil, err + } + req, err := http.NewRequest("POST", config.PoolSwapQuoteURL, bytes.NewBuffer(payloadBytes)) + if err != nil { + return nil, err + } + _, err = doRequest(ctx, req, &r) + if err != nil { + return nil, err + } + return &r, nil +} + +func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { + var r models.PoolSwapResult + + //swap payload + payload := map[string]string{ + "amount": amount, + "from": from, + "fromTokenAddress": fromTokenAddress, + "poolAddress": poolAddress, + "toTokenAddress": toTokenAddress, + } + + payloadBytes, err := json.Marshal(payload) + if err != nil { + return nil, err + } + req, err := http.NewRequest("POST", config.PoolSwapQuoteURL, bytes.NewBuffer(payloadBytes)) + if err != nil { + return nil, err + } + _, err = doRequest(ctx, req, &r) + if err != nil { + return nil, err + } + return &r, nil +} + // TODO: Use actual custodial api to request available alias func (as *HTTPAccountService) RequestAlias(ctx context.Context, publicKey string, hint string) (*models.RequestAliasResult, error) { if as.SS == nil { From aef8efa2bf26700f4c14bb48f14bf5f26f72e73e Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Wed, 5 Mar 2025 16:42:55 +0300 Subject: [PATCH 03/22] add pool api responses --- models/pool_swap_response.go | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 models/pool_swap_response.go diff --git a/models/pool_swap_response.go b/models/pool_swap_response.go new file mode 100644 index 0000000..8842d67 --- /dev/null +++ b/models/pool_swap_response.go @@ -0,0 +1,14 @@ +package models + +type PoolDepositResult struct { + TrackingId string `json:"trackingId"` +} + +type PoolSwapQuoteResult struct { + IncludesFeesDeduction bool `json:"includesFeesDeduction"` + OutValue string `json:"outValue"` +} + +type PoolSwapResult struct { + TrackingId string `json:"trackingId"` +} From 35f24b5183758e34032fb77be8358f2627233fcc Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 6 Mar 2025 18:14:34 +0300 Subject: [PATCH 04/22] Use the latest ussd-data-service --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 0d62c17..4b25b5f 100644 --- a/go.mod +++ b/go.mod @@ -8,7 +8,7 @@ require ( git.grassecon.net/grassrootseconomics/visedriver v0.8.0-beta.10.0.20250122123424-6749c632b0a2 github.com/gofrs/uuid v4.4.0+incompatible github.com/grassrootseconomics/eth-custodial v1.3.0-beta - github.com/grassrootseconomics/ussd-data-service v1.2.0-beta + github.com/grassrootseconomics/ussd-data-service v1.4.0-beta github.com/stretchr/testify v1.9.0 ) diff --git a/go.sum b/go.sum index c88d977..6653efe 100644 --- a/go.sum +++ b/go.sum @@ -18,6 +18,8 @@ github.com/grassrootseconomics/eth-custodial v1.3.0-beta h1:twrMBhl89GqDUL9PlkzQ github.com/grassrootseconomics/eth-custodial v1.3.0-beta/go.mod h1:7uhRcdnJplX4t6GKCEFkbeDhhjlcaGJeJqevbcvGLZo= github.com/grassrootseconomics/ussd-data-service v1.2.0-beta h1:fn1gwbWIwHVEBtUC2zi5OqTlfI/5gU1SMk0fgGixIXk= github.com/grassrootseconomics/ussd-data-service v1.2.0-beta/go.mod h1:omfI0QtUwIdpu9gMcUqLMCG8O1XWjqJGBx1qUMiGWC0= +github.com/grassrootseconomics/ussd-data-service v1.4.0-beta h1:4fMd/3h2ZIhRg4GdHQmRw5FfD3MpJvFNNJQo+Q27f5M= +github.com/grassrootseconomics/ussd-data-service v1.4.0-beta/go.mod h1:9sGnorpKaK76FmOGXoh/xv7x5siSFNYdXxQo9BKW4DI= github.com/graygnuorg/go-gdbm v0.0.0-20220711140707-71387d66dce4 h1:U4kkNYryi/qfbBF8gh7Vsbuz+cVmhf5kt6pE9bYYyLo= github.com/graygnuorg/go-gdbm v0.0.0-20220711140707-71387d66dce4/go.mod h1:zpZDgZFzeq9s0MIeB1P50NIEWDFFHSFBohI/NbaTD/Y= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= From f723e0aa45cc49d4fb39878897793584d33d9948 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Fri, 7 Mar 2025 08:09:41 +0300 Subject: [PATCH 05/22] add sample test data --- dev/data/swap_from.json | 32 ++++++++++++++++++++++++++++++ dev/data/swap_to.json | 14 ++++++++++++++ dev/data/top_pools.json | 43 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 89 insertions(+) create mode 100644 dev/data/swap_from.json create mode 100644 dev/data/swap_to.json create mode 100644 dev/data/top_pools.json diff --git a/dev/data/swap_from.json b/dev/data/swap_from.json new file mode 100644 index 0000000..e523972 --- /dev/null +++ b/dev/data/swap_from.json @@ -0,0 +1,32 @@ +{ + "ok": true, + "description": "Swap from list", + "result": { + "filtered": [ + { + "contractAddress": "0xc7B78Ac9ACB9E025C8234621FC515bC58179dEAe", + "tokenSymbol": "AMANI", + "tokenDecimals": "6", + "balance": "" + }, + { + "contractAddress": "0xF0C3C7581b8b96B59a97daEc8Bd48247cE078674", + "tokenSymbol": "AMUA", + "tokenDecimals": "6", + "balance": "" + }, + { + "contractAddress": "0x371455a30fc62736145Bd8429Fcc6481186f235F", + "tokenSymbol": "BAHARI", + "tokenDecimals": "6", + "balance": "" + }, + { + "contractAddress": "0x7cA6113b59c24a880F382C7E12d609a6Eb05246b", + "tokenSymbol": "BANGLA", + "tokenDecimals": "6", + "balance": "" + } + ] + } +} \ No newline at end of file diff --git a/dev/data/swap_to.json b/dev/data/swap_to.json new file mode 100644 index 0000000..c8906b6 --- /dev/null +++ b/dev/data/swap_to.json @@ -0,0 +1,14 @@ +{ + "ok": true, + "description": "Swap to list", + "result": { + "filtered": [ + { + "contractAddress": "0x765DE816845861e75A25fCA122bb6898B8B1282a", + "tokenSymbol": "cUSD", + "tokenDecimals": "18", + "balance": "" + } + ] + } +} \ No newline at end of file diff --git a/dev/data/top_pools.json b/dev/data/top_pools.json new file mode 100644 index 0000000..85e120c --- /dev/null +++ b/dev/data/top_pools.json @@ -0,0 +1,43 @@ +{ + "ok": true, + "description": "Top 5 pools sorted by swaps", + "result": { + "topPools": [ + { + "poolName": "Kenya ROLA Pool", + "poolSymbol": "ROLA", + "poolContractAddress": "0x48a953cA5cf5298bc6f6Af3C608351f537AAcb9e", + "limiterAddress": "", + "voucherRegistry": "" + }, + { + "poolName": "Nairobi ROLA Pool", + "poolSymbol": "NAIROBI", + "poolContractAddress": "0xB0660Ac1Ee3d32ea35bc728D7CA1705Fa5A37528", + "limiterAddress": "", + "voucherRegistry": "" + }, + { + "poolName": "Friends of Kiriba Ecosystem ", + "poolSymbol": "FRIENDS", + "poolContractAddress": "0xC4848263821FA02baB2181910A2eFb9CECb2c21C", + "limiterAddress": "", + "voucherRegistry": "" + }, + { + "poolName": "Resilient Community Waqfs", + "poolSymbol": "REZILIENS", + "poolContractAddress": "0x1e40951d7a28147D8B4A554C60c42766C92e2Fc6", + "limiterAddress": "", + "voucherRegistry": "" + }, + { + "poolName": "GrE Tech", + "poolSymbol": "GRET", + "poolContractAddress": "0xb7B9d0A264eD1a8E2418571B7AC5933C79C9c2B8", + "limiterAddress": "", + "voucherRegistry": "" + } + ] + } +} \ No newline at end of file From b05734f976cc8dc4d06fb8d189c3917f46e51e91 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Fri, 7 Mar 2025 08:11:04 +0300 Subject: [PATCH 06/22] feat: add fetch pools,swappable pool vouchers --- dev/api.go | 155 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) diff --git a/dev/api.go b/dev/api.go index fc68c29..1ebbe7c 100644 --- a/dev/api.go +++ b/dev/api.go @@ -6,7 +6,9 @@ import ( "crypto/sha1" "encoding/json" "fmt" + "log" "math/rand" + "os" "regexp" "strconv" "strings" @@ -91,6 +93,11 @@ type Voucher struct { Location string `json: "location"` } +type Pool struct { + vouchers []Voucher + poolLimit map[string]string +} + type DevAccountService struct { db db.Db accounts map[string]Account @@ -106,6 +113,7 @@ type DevAccountService struct { defaultAccount string emitterFunc event.EmitterFunc pfx []byte + pool Pool } func NewDevAccountService(ctx context.Context, ss storage.StorageService) *DevAccountService { @@ -118,6 +126,7 @@ func NewDevAccountService(ctx context.Context, ss storage.StorageService) *DevAc txs: make(map[string]Tx), txsTrack: make(map[string]string), autoVoucherValue: make(map[string]int), + pool: Pool{}, defaultAccount: zeroAddress, pfx: []byte("__"), } @@ -171,6 +180,15 @@ func (das *DevAccountService) loadAccount(ctx context.Context, pubKey string, v return nil } +func (p *Pool) hasVoucher(voucherAddress string) bool { + for _, value := range p.vouchers { + if value.Address == voucherAddress { + return true + } + } + return false +} + func (das *DevAccountService) loadTx(ctx context.Context, hsh string, v []byte) error { var mytx Tx @@ -415,6 +433,74 @@ func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.Accoun }, nil } +func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { + sym, ok := das.vouchersAddress[tokenAddress] + if !ok { + return nil, fmt.Errorf("voucher address %v not found", tokenAddress) + } + uid, err := uuid.NewV4() + if err != nil { + return nil, err + } + + voucher, ok := das.vouchers[sym] + if !ok { + return nil, fmt.Errorf("voucher address %v found but does not resolve", tokenAddress) + } + + das.pool = Pool{ + vouchers: append(das.pool.vouchers, voucher), + poolLimit: map[string]string{tokenAddress: amount}, + } + return &models.PoolDepositResult{ + TrackingId: uid.String(), + }, nil +} + +func (das *DevAccountService) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) { + _, ok := das.accounts[from] + if !ok { + return nil, fmt.Errorf("account not found (publickey): %v", from) + } + //resolve the token address you are trying to swap from(fromTokenAddress) + _, ok = das.vouchersAddress[fromTokenAddress] + if !ok { + return nil, fmt.Errorf("voucher address %v not found", fromTokenAddress) + } + p := das.pool + + //check if pool has voucher to swap to + if !p.hasVoucher(toTokenAddress) { + return nil, fmt.Errorf("Voucher with address: %v not found in the pool", toTokenAddress) + } + //Return a a quote that is equal to the amount enter + return &models.PoolSwapQuoteResult{IncludesFeesDeduction: false, OutValue: amount}, nil +} + +func (das *DevAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { + uid, err := uuid.NewV4() + if err != nil { + return nil, err + } + + _, ok := das.accounts[from] + if !ok { + return nil, fmt.Errorf("account not found (publickey): %v", from) + } + _, ok = das.vouchersAddress[fromTokenAddress] + if !ok { + return nil, fmt.Errorf("voucher address %v not found", fromTokenAddress) + } + p := das.pool + + //check if pool has voucher to swap to + if !p.hasVoucher(toTokenAddress) { + return nil, fmt.Errorf("Voucher with address: %v not found in the pool", toTokenAddress) + } + + return &models.PoolSwapResult{TrackingId: uid.String()}, nil +} + func (das *DevAccountService) TrackAccountStatus(ctx context.Context, publicKey string) (*models.TrackStatusResult, error) { var ok bool _, ok = das.accounts[publicKey] @@ -653,3 +739,72 @@ func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string Alias: alias, }, nil } + +func (das *DevAccountService) FetchTopPools(ctx context.Context) ([]models.Pool, error) { + var ( + r struct { + OK bool `json:"ok"` + Description string `json:"description"` + Result struct { + Pools []models.Pool `json:"topPools"` + } `json:"result"` + } + ) + data, err := os.ReadFile("./data/top_pools.json") + if err != nil { + log.Fatal(err) + } + + err = json.Unmarshal(data, &r) + if err != nil { + log.Fatal(err) + } + + return r.Result.Pools, nil +} + +func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { + var ( + r struct { + OK bool `json:"ok"` + Description string `json:"description"` + Result struct { + SwappableVouchers []models.SwappableVoucher `json:"filtered"` + } `json:"result"` + } + ) + data, err := os.ReadFile("./data/swap_from.json") + if err != nil { + log.Fatal(err) + } + + err = json.Unmarshal(data, &r) + if err != nil { + log.Fatal(err) + } + + return r.Result.SwappableVouchers, nil +} + +func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { + var ( + r struct { + OK bool `json:"ok"` + Description string `json:"description"` + Result struct { + SwappableVouchers []models.SwappableVoucher `json:"filtered"` + } `json:"result"` + } + ) + data, err := os.ReadFile("./data/swap_to.json") + if err != nil { + log.Fatal(err) + } + + err = json.Unmarshal(data, &r) + if err != nil { + log.Fatal(err) + } + + return r.Result.SwappableVouchers, nil +} From 67d7ec156728ead0166d0f83b616aa98e2d8d592 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Fri, 7 Mar 2025 08:11:33 +0300 Subject: [PATCH 07/22] add pool structs --- models/pool.go | 10 ++++++++++ models/voucher_data_result.go | 7 +++++++ 2 files changed, 17 insertions(+) create mode 100644 models/pool.go diff --git a/models/pool.go b/models/pool.go new file mode 100644 index 0000000..9e784b3 --- /dev/null +++ b/models/pool.go @@ -0,0 +1,10 @@ +package models + + +type Pool struct { + PoolName string `json:"poolName"` + PoolSymbol string `json:"poolSymbol"` + PoolContractAddress string `json:"poolContractAddress"` + LimiterAddress string `json:"limiterAddress"` + VoucherRegistry string `json:"voucherRegistry"` +} diff --git a/models/voucher_data_result.go b/models/voucher_data_result.go index 9a10831..1311482 100644 --- a/models/voucher_data_result.go +++ b/models/voucher_data_result.go @@ -8,3 +8,10 @@ type VoucherDataResult struct { TokenCommodity string `json:"tokenCommodity"` TokenLocation string `json:"tokenLocation"` } + +type SwappableVoucher struct { + ContractAddress string `json:"contractAddress"` + TokenSymbol string `json:"tokenSymbol"` + TokenDecimals string `json:"tokenDecimals"` + Balance string `json:"balance"` +} From e8c58a8f3308ea724ad14eb4618d700c63d6cc52 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Fri, 7 Mar 2025 08:13:15 +0300 Subject: [PATCH 08/22] feat: implement fetch pools,pool swappable vouchers with dummy data --- remote/http/service.go | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/remote/http/service.go b/remote/http/service.go index 86a856a..7bad334 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -239,6 +239,11 @@ func resolveAliasAddress(ctx context.Context, alias string) (*models.AliasAddres return &r, err } +func (as *HTTPAccountService) FetchTopPools(ctx context.Context) ([]models.Pool, error) { + svc := dev.NewDevAccountService(ctx, as.SS) + return svc.FetchTopPools(ctx) +} + func (as *HTTPAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { var r models.PoolDepositResult @@ -292,6 +297,14 @@ func (as *HTTPAccountService) GetPoolSwapQuote(ctx context.Context, amount, from return &r, nil } +func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { + return as.GetPoolSwappableFromVouchers(ctx) +} + +func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { + return as.GetPoolSwappableVouchers(ctx) +} + func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { var r models.PoolSwapResult From d7ae1cc096533eee9f7e7204d53da87319a9007a Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 13:59:05 +0300 Subject: [PATCH 09/22] Include the account's public key --- remote/http/service.go | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/remote/http/service.go b/remote/http/service.go index 7bad334..3792f5b 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -239,9 +239,9 @@ func resolveAliasAddress(ctx context.Context, alias string) (*models.AliasAddres return &r, err } -func (as *HTTPAccountService) FetchTopPools(ctx context.Context) ([]models.Pool, error) { +func (as *HTTPAccountService) FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) { svc := dev.NewDevAccountService(ctx, as.SS) - return svc.FetchTopPools(ctx) + return svc.FetchTopPools(ctx, publicKey) } func (as *HTTPAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { @@ -297,12 +297,12 @@ func (as *HTTPAccountService) GetPoolSwapQuote(ctx context.Context, amount, from return &r, nil } -func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { - return as.GetPoolSwappableFromVouchers(ctx) +func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + return as.GetPoolSwappableFromVouchers(ctx, publicKey) } -func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { - return as.GetPoolSwappableVouchers(ctx) +func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + return as.GetPoolSwappableVouchers(ctx, publicKey) } func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { From 52e1be1104e5170e8eef2728a699c7a984f8bc48 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 14:00:16 +0300 Subject: [PATCH 10/22] Return an array of data instead of reading from the file --- dev/api.go | 133 +++++++++++++++++++++++++++++------------------------ 1 file changed, 74 insertions(+), 59 deletions(-) diff --git a/dev/api.go b/dev/api.go index 1ebbe7c..5e9ca9b 100644 --- a/dev/api.go +++ b/dev/api.go @@ -6,9 +6,7 @@ import ( "crypto/sha1" "encoding/json" "fmt" - "log" "math/rand" - "os" "regexp" "strconv" "strings" @@ -740,71 +738,88 @@ func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string }, nil } -func (das *DevAccountService) FetchTopPools(ctx context.Context) ([]models.Pool, error) { - var ( - r struct { - OK bool `json:"ok"` - Description string `json:"description"` - Result struct { - Pools []models.Pool `json:"topPools"` - } `json:"result"` - } - ) - data, err := os.ReadFile("./data/top_pools.json") - if err != nil { - log.Fatal(err) +func (das *DevAccountService) FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) { + topPools := []dataserviceapi.PoolDetails{ + { + PoolName: "Kenya ROLA Pool", + PoolSymbol: "ROLA", + PoolContractAdrress: "0x48a953cA5cf5298bc6f6Af3C608351f537AAcb9e", + LimiterAddress: "", + VoucherRegistry: "", + }, + { + PoolName: "Nairobi ROLA Pool", + PoolSymbol: "NAIROBI", + PoolContractAdrress: "0xB0660Ac1Ee3d32ea35bc728D7CA1705Fa5A37528", + LimiterAddress: "", + VoucherRegistry: "", + }, + { + PoolName: "Friends of Kiriba Ecosystem", + PoolSymbol: "FRIENDS", + PoolContractAdrress: "0xC4848263821FA02baB2181910A2eFb9CECb2c21C", + LimiterAddress: "", + VoucherRegistry: "", + }, + { + PoolName: "Resilient Community Waqfs", + PoolSymbol: "REZILIENS", + PoolContractAdrress: "0x1e40951d7a28147D8B4A554C60c42766C92e2Fc6", + LimiterAddress: "", + VoucherRegistry: "", + }, + { + PoolName: "GrE Tech", + PoolSymbol: "GRET", + PoolContractAdrress: "0xb7B9d0A264eD1a8E2418571B7AC5933C79C9c2B8", + LimiterAddress: "", + VoucherRegistry: "", + }, } - err = json.Unmarshal(data, &r) - if err != nil { - log.Fatal(err) - } - - return r.Result.Pools, nil + return topPools, nil } -func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { - var ( - r struct { - OK bool `json:"ok"` - Description string `json:"description"` - Result struct { - SwappableVouchers []models.SwappableVoucher `json:"filtered"` - } `json:"result"` - } - ) - data, err := os.ReadFile("./data/swap_from.json") - if err != nil { - log.Fatal(err) +func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + swapFromList := []dataserviceapi.TokenHoldings{ + { + ContractAddress: "0xc7B78Ac9ACB9E025C8234621FC515bC58179dEAe", + TokenSymbol: "AMANI", + TokenDecimals: "6", + Balance: "", + }, + { + ContractAddress: "0xF0C3C7581b8b96B59a97daEc8Bd48247cE078674", + TokenSymbol: "AMUA", + TokenDecimals: "6", + Balance: "", + }, + { + ContractAddress: "0x371455a30fc62736145Bd8429Fcc6481186f235F", + TokenSymbol: "BAHARI", + TokenDecimals: "6", + Balance: "", + }, + { + ContractAddress: "0x7cA6113b59c24a880F382C7E12d609a6Eb05246b", + TokenSymbol: "BANGLA", + TokenDecimals: "6", + Balance: "", + }, } - err = json.Unmarshal(data, &r) - if err != nil { - log.Fatal(err) - } - - return r.Result.SwappableVouchers, nil + return swapFromList, nil } -func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context) ([]models.SwappableVoucher, error) { - var ( - r struct { - OK bool `json:"ok"` - Description string `json:"description"` - Result struct { - SwappableVouchers []models.SwappableVoucher `json:"filtered"` - } `json:"result"` - } - ) - data, err := os.ReadFile("./data/swap_to.json") - if err != nil { - log.Fatal(err) +func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + swapToList := []dataserviceapi.TokenHoldings{ + { + ContractAddress: "0x765DE816845861e75A25fCA122bb6898B8B1282a", + TokenSymbol: "cUSD", + TokenDecimals: "18", + Balance: "", + }, } - err = json.Unmarshal(data, &r) - if err != nil { - log.Fatal(err) - } - - return r.Result.SwappableVouchers, nil + return swapToList, nil } From a04f7ee66c3557a94d97aa902edf1732563fc4ff Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 14:03:30 +0300 Subject: [PATCH 11/22] Remove unused model structs --- models/pool.go | 10 ---------- models/voucher_data_result.go | 7 ------- 2 files changed, 17 deletions(-) delete mode 100644 models/pool.go diff --git a/models/pool.go b/models/pool.go deleted file mode 100644 index 9e784b3..0000000 --- a/models/pool.go +++ /dev/null @@ -1,10 +0,0 @@ -package models - - -type Pool struct { - PoolName string `json:"poolName"` - PoolSymbol string `json:"poolSymbol"` - PoolContractAddress string `json:"poolContractAddress"` - LimiterAddress string `json:"limiterAddress"` - VoucherRegistry string `json:"voucherRegistry"` -} diff --git a/models/voucher_data_result.go b/models/voucher_data_result.go index 1311482..9a10831 100644 --- a/models/voucher_data_result.go +++ b/models/voucher_data_result.go @@ -8,10 +8,3 @@ type VoucherDataResult struct { TokenCommodity string `json:"tokenCommodity"` TokenLocation string `json:"tokenLocation"` } - -type SwappableVoucher struct { - ContractAddress string `json:"contractAddress"` - TokenSymbol string `json:"tokenSymbol"` - TokenDecimals string `json:"tokenDecimals"` - Balance string `json:"balance"` -} From e3b6c25792c21ec735286449afa0fc2afdc586d7 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 14:17:03 +0300 Subject: [PATCH 12/22] Added the swap functions to the accountService interface --- remote/account_service.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/remote/account_service.go b/remote/account_service.go index 2c67b12..ff9ec8f 100644 --- a/remote/account_service.go +++ b/remote/account_service.go @@ -17,4 +17,10 @@ type AccountService interface { TokenTransfer(ctx context.Context, amount, from, to, tokenAddress string) (*models.TokenTransferResponse, error) CheckAliasAddress(ctx context.Context, alias string) (*models.AliasAddress, error) RequestAlias(ctx context.Context, hint string, publicKey string) (*models.RequestAliasResult, error) + PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) + FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) + GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) + GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) + GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) + PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) } From ba8d2a19c2edef703878062565d8bb50eccd3a3b Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 16:39:37 +0300 Subject: [PATCH 13/22] Use the DevAccountService functions to retrieve the data --- remote/http/service.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/remote/http/service.go b/remote/http/service.go index 3792f5b..48bf678 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -298,11 +298,13 @@ func (as *HTTPAccountService) GetPoolSwapQuote(ctx context.Context, amount, from } func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { - return as.GetPoolSwappableFromVouchers(ctx, publicKey) + svc := dev.NewDevAccountService(ctx, as.SS) + return svc.GetPoolSwappableFromVouchers(ctx, publicKey) } func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { - return as.GetPoolSwappableVouchers(ctx, publicKey) + svc := dev.NewDevAccountService(ctx, as.SS) + return svc.GetPoolSwappableVouchers(ctx, publicKey) } func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { From d4f27af7a7ac71d48b33eb2d9385f66bca7650f4 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Fri, 7 Mar 2025 12:53:02 +0300 Subject: [PATCH 14/22] add check for account when doing a pool deposit --- dev/api.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/dev/api.go b/dev/api.go index 5e9ca9b..749c99e 100644 --- a/dev/api.go +++ b/dev/api.go @@ -432,6 +432,11 @@ func (das *DevAccountService) CreateAccount(ctx context.Context) (*models.Accoun } func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { + _, ok := das.accounts[from] + if !ok { + return nil, fmt.Errorf("account not found (publickey): %v", from) + } + sym, ok := das.vouchersAddress[tokenAddress] if !ok { return nil, fmt.Errorf("voucher address %v not found", tokenAddress) From 37a2006a0b736d1c8f001f4173468680f03d64d3 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Mon, 10 Mar 2025 16:49:53 +0300 Subject: [PATCH 15/22] feat: persist and load pool info --- dev/api.go | 37 ++++++++++++++++++++++++++++++++++++- 1 file changed, 36 insertions(+), 1 deletion(-) diff --git a/dev/api.go b/dev/api.go index 749c99e..62c3cf1 100644 --- a/dev/api.go +++ b/dev/api.go @@ -34,6 +34,8 @@ const ( defaultDecimals = 6 zeroAddress string = "0x0000000000000000000000000000000000000000" defaultVoucherBalance float64 = 500.00 + cityPoolAddress string = "0x3b517308D858a47458aD5C8E699697C5dc91Da0F" + poolName string = "citypool" ) type Tx struct { @@ -92,6 +94,8 @@ type Voucher struct { } type Pool struct { + name string + address string vouchers []Voucher poolLimit map[string]string } @@ -124,7 +128,7 @@ func NewDevAccountService(ctx context.Context, ss storage.StorageService) *DevAc txs: make(map[string]Tx), txsTrack: make(map[string]string), autoVoucherValue: make(map[string]int), - pool: Pool{}, + pool: Pool{address: cityPoolAddress, name: poolName}, defaultAccount: zeroAddress, pfx: []byte("__"), } @@ -209,6 +213,20 @@ func (das *DevAccountService) loadAlias(ctx context.Context, alias string, key [ return nil } +func (das *DevAccountService) loadPoolInfo(ctx context.Context, name string, key []byte) error { + var pool Pool + poolB, err := das.db.Get(ctx, key) + if err != nil { + return err + } + err = json.Unmarshal(poolB, &pool) + if err != nil { + return fmt.Errorf("failed to unmarshall pool info: %v", err) + } + das.pool = pool + return nil +} + func (das *DevAccountService) loadItem(ctx context.Context, k []byte, v []byte) error { var err error s := string(k) @@ -225,6 +243,8 @@ func (das *DevAccountService) loadItem(ctx context.Context, k []byte, v []byte) } else if ss[0] == "alias" { err = das.loadAlias(ctx, ss[1], k) logg.ErrorCtxf(ctx, "loading aliases failed", "error_load_aliases", err) + } else if ss[0] == "pool" { + err = das.loadPoolInfo(ctx, ss[1], v) } else { logg.ErrorCtxf(ctx, "unknown double underscore key", "key", ss[0]) } @@ -361,6 +381,20 @@ func (das *DevAccountService) saveAccount(ctx context.Context, acc Account) erro return das.db.Put(ctx, []byte(k), v) } +func (das *DevAccountService) savePoolInfo(ctx context.Context, pool Pool) error { + if das.db == nil { + return nil + } + k := das.prefixKeyFor("pool", pool.name) + v, err := json.Marshal(pool) + if err != nil { + return err + } + das.db.SetSession("") + das.db.SetPrefix(db.DATATYPE_USERDATA) + 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") @@ -455,6 +489,7 @@ func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poo vouchers: append(das.pool.vouchers, voucher), poolLimit: map[string]string{tokenAddress: amount}, } + das.savePoolInfo(ctx, das.pool) return &models.PoolDepositResult{ TrackingId: uid.String(), }, nil From 3b39b86d09875c055be76390f7b05dee5d33c122 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Mon, 10 Mar 2025 17:12:05 +0300 Subject: [PATCH 16/22] pass the correct arguments to the swap functions --- dev/api.go | 6 +++--- remote/account_service.go | 6 +++--- remote/http/service.go | 12 ++++++------ 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/dev/api.go b/dev/api.go index 62c3cf1..d469bc1 100644 --- a/dev/api.go +++ b/dev/api.go @@ -778,7 +778,7 @@ func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string }, nil } -func (das *DevAccountService) FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) { +func (das *DevAccountService) FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) { topPools := []dataserviceapi.PoolDetails{ { PoolName: "Kenya ROLA Pool", @@ -820,7 +820,7 @@ func (das *DevAccountService) FetchTopPools(ctx context.Context, publicKey strin return topPools, nil } -func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { +func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { swapFromList := []dataserviceapi.TokenHoldings{ { ContractAddress: "0xc7B78Ac9ACB9E025C8234621FC515bC58179dEAe", @@ -851,7 +851,7 @@ func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context, return swapFromList, nil } -func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { +func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { swapToList := []dataserviceapi.TokenHoldings{ { ContractAddress: "0x765DE816845861e75A25fCA122bb6898B8B1282a", diff --git a/remote/account_service.go b/remote/account_service.go index ff9ec8f..fdb7021 100644 --- a/remote/account_service.go +++ b/remote/account_service.go @@ -18,9 +18,9 @@ type AccountService interface { CheckAliasAddress(ctx context.Context, alias string) (*models.AliasAddress, error) RequestAlias(ctx context.Context, hint string, publicKey string) (*models.RequestAliasResult, error) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) - FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) - GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) - GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) + FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) + GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) + GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) } diff --git a/remote/http/service.go b/remote/http/service.go index 48bf678..2ee9a22 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -239,9 +239,9 @@ func resolveAliasAddress(ctx context.Context, alias string) (*models.AliasAddres return &r, err } -func (as *HTTPAccountService) FetchTopPools(ctx context.Context, publicKey string) ([]dataserviceapi.PoolDetails, error) { +func (as *HTTPAccountService) FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) { svc := dev.NewDevAccountService(ctx, as.SS) - return svc.FetchTopPools(ctx, publicKey) + return svc.FetchTopPools(ctx) } func (as *HTTPAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { @@ -297,14 +297,14 @@ func (as *HTTPAccountService) GetPoolSwapQuote(ctx context.Context, amount, from return &r, nil } -func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { +func (as *HTTPAccountService) GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { svc := dev.NewDevAccountService(ctx, as.SS) - return svc.GetPoolSwappableFromVouchers(ctx, publicKey) + return svc.GetPoolSwappableFromVouchers(ctx, poolAddress, publicKey) } -func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context, publicKey string) ([]dataserviceapi.TokenHoldings, error) { +func (as *HTTPAccountService) GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { svc := dev.NewDevAccountService(ctx, as.SS) - return svc.GetPoolSwappableVouchers(ctx, publicKey) + return svc.GetPoolSwappableVouchers(ctx, poolAddress, publicKey) } func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { From 17e89e0b8828fc5a71a365586d7912b6418e5bdd Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 11 Mar 2025 15:46:17 +0300 Subject: [PATCH 17/22] Added the GetSwapFromTokenMaxLimit --- dev/api.go | 6 ++++++ remote/account_service.go | 1 + remote/http/service.go | 5 +++++ 3 files changed, 12 insertions(+) diff --git a/dev/api.go b/dev/api.go index d469bc1..182db88 100644 --- a/dev/api.go +++ b/dev/api.go @@ -863,3 +863,9 @@ func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context, pool return swapToList, nil } + +func (das *DevAccountService) GetSwapFromTokenMaxLimit(ctx context.Context, poolAddress, fromTokenAddress, toTokenAddress, publicKey string) (*models.MaxLimitResult, error) { + return &models.MaxLimitResult{ + Max: "1339482", + }, nil +} diff --git a/remote/account_service.go b/remote/account_service.go index fdb7021..cabd4d8 100644 --- a/remote/account_service.go +++ b/remote/account_service.go @@ -23,4 +23,5 @@ type AccountService interface { GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) + GetSwapFromTokenMaxLimit(ctx context.Context, poolAddress, fromTokenAddress, toTokenAddress, publicKey string) (*models.MaxLimitResult, error) } diff --git a/remote/http/service.go b/remote/http/service.go index 2ee9a22..a0bed1e 100644 --- a/remote/http/service.go +++ b/remote/http/service.go @@ -334,6 +334,11 @@ func (as *HTTPAccountService) PoolSwap(ctx context.Context, amount, from, fromTo return &r, nil } +func (as *HTTPAccountService) GetSwapFromTokenMaxLimit(ctx context.Context, poolAddress, fromTokenAddress, toTokenAddress, publicKey string) (*models.MaxLimitResult, error) { + svc := dev.NewDevAccountService(ctx, as.SS) + return svc.GetSwapFromTokenMaxLimit(ctx, poolAddress, fromTokenAddress, toTokenAddress, publicKey) +} + // TODO: Use actual custodial api to request available alias func (as *HTTPAccountService) RequestAlias(ctx context.Context, publicKey string, hint string) (*models.RequestAliasResult, error) { if as.SS == nil { From 3244c717cbeea0ad25f279ca3b10a1d082bcc87c Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Tue, 11 Mar 2025 15:46:51 +0300 Subject: [PATCH 18/22] Added the MaxLimitResult struct model --- models/pool_swap_response.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/models/pool_swap_response.go b/models/pool_swap_response.go index 8842d67..35b2e12 100644 --- a/models/pool_swap_response.go +++ b/models/pool_swap_response.go @@ -12,3 +12,7 @@ type PoolSwapQuoteResult struct { type PoolSwapResult struct { TrackingId string `json:"trackingId"` } + +type MaxLimitResult struct { + Max string `json:"max"` +} From 5432365874375fa6829d78900c08a8234c88e4b0 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Wed, 12 Mar 2025 23:18:36 +0300 Subject: [PATCH 19/22] add logs,use same pool instance --- dev/api.go | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/dev/api.go b/dev/api.go index 182db88..b07eb52 100644 --- a/dev/api.go +++ b/dev/api.go @@ -213,17 +213,15 @@ func (das *DevAccountService) loadAlias(ctx context.Context, alias string, key [ return nil } -func (das *DevAccountService) loadPoolInfo(ctx context.Context, name string, key []byte) error { +func (das *DevAccountService) loadPoolInfo(ctx context.Context, name string, v []byte) error { var pool Pool - poolB, err := das.db.Get(ctx, key) - if err != nil { - return err - } - err = json.Unmarshal(poolB, &pool) + + err := json.Unmarshal(v, &pool) if err != nil { return fmt.Errorf("failed to unmarshall pool info: %v", err) } das.pool = pool + logg.InfoCtxf(ctx, "loaded pool info", "name", das.pool.name, "vouchers", das.pool.vouchers) return nil } @@ -260,13 +258,13 @@ func (das *DevAccountService) loadAll(ctx context.Context) error { } for true { k, v := dumper.Next(ctx) + logg.InfoCtxf(ctx, "loading all", "key", string(k), "value", string(v)) if k == nil { break } if !bytes.HasPrefix(k, das.pfx) { continue } - err = das.loadItem(ctx, k, v) if err != nil { return err @@ -485,11 +483,13 @@ func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poo return nil, fmt.Errorf("voucher address %v found but does not resolve", tokenAddress) } - das.pool = Pool{ - vouchers: append(das.pool.vouchers, voucher), - poolLimit: map[string]string{tokenAddress: amount}, + das.pool.vouchers = append(das.pool.vouchers, voucher) + das.pool.poolLimit = map[string]string{tokenAddress: amount} + + err = das.savePoolInfo(ctx, das.pool) + if err != nil { + return nil, err } - das.savePoolInfo(ctx, das.pool) return &models.PoolDepositResult{ TrackingId: uid.String(), }, nil @@ -511,7 +511,7 @@ func (das *DevAccountService) GetPoolSwapQuote(ctx context.Context, amount, from if !p.hasVoucher(toTokenAddress) { return nil, fmt.Errorf("Voucher with address: %v not found in the pool", toTokenAddress) } - //Return a a quote that is equal to the amount enter + //Return a a quote that is equal to the amount entered return &models.PoolSwapQuoteResult{IncludesFeesDeduction: false, OutValue: amount}, nil } From 3c2889ac72f0f09abac7604a2a820081d8542cc7 Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 13 Mar 2025 10:05:49 +0300 Subject: [PATCH 20/22] Added pool swap functions to the TestAccountService --- testutil/testservice/account_service.go | 28 +++++++++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/testutil/testservice/account_service.go b/testutil/testservice/account_service.go index 12b9de4..445fd9b 100644 --- a/testutil/testservice/account_service.go +++ b/testutil/testservice/account_service.go @@ -57,6 +57,10 @@ func (tas *TestAccountService) TokenTransfer(ctx context.Context, amount, from, }, nil } +func (m TestAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { + return &models.PoolDepositResult{}, nil +} + func (m TestAccountService) CheckAliasAddress(ctx context.Context, alias string) (*models.AliasAddress, error) { return &models.AliasAddress{}, nil } @@ -64,3 +68,27 @@ func (m TestAccountService) CheckAliasAddress(ctx context.Context, alias string) func (m TestAccountService) RequestAlias(ctx context.Context, publicKey string, hint string) (*models.RequestAliasResult, error) { return &models.RequestAliasResult{}, nil } + +func (m TestAccountService) FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) { + return []dataserviceapi.PoolDetails{}, nil +} + +func (m TestAccountService) GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + return []dataserviceapi.TokenHoldings{}, nil +} + +func (m TestAccountService) GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + return []dataserviceapi.TokenHoldings{}, nil +} + +func (m TestAccountService) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) { + return &models.PoolSwapQuoteResult{}, nil +} + +func (m TestAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { + return &models.PoolSwapResult{}, nil +} + +func (m TestAccountService) GetSwapFromTokenMaxLimit(ctx context.Context, poolAddress, fromTokenAddress, toTokenAddress, publicKey string) (*models.MaxLimitResult, error) { + return &models.MaxLimitResult{}, nil +} From ba43610ff00bec4eeb50078833badff2d1032f8b Mon Sep 17 00:00:00 2001 From: alfred-mk Date: Thu, 13 Mar 2025 10:14:11 +0300 Subject: [PATCH 21/22] Added pool swap functions to the MockAccountService --- testutil/mocks/service_mock.go | 35 ++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/testutil/mocks/service_mock.go b/testutil/mocks/service_mock.go index bfa9222..42bcb28 100644 --- a/testutil/mocks/service_mock.go +++ b/testutil/mocks/service_mock.go @@ -57,3 +57,38 @@ func (m MockAccountService) RequestAlias(ctx context.Context, publicKey string, args := m.Called(publicKey, hint) return args.Get(0).(*models.RequestAliasResult), args.Error(1) } + +func (m MockAccountService) PoolDeposit(ctx context.Context, amount, from, poolAddress, tokenAddress string) (*models.PoolDepositResult, error) { + args := m.Called(amount, from, poolAddress, tokenAddress) + return args.Get(0).(*models.PoolDepositResult), args.Error(1) +} + +func (m MockAccountService) FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) { + args := m.Called() + return args.Get(0).([]dataserviceapi.PoolDetails), args.Error(1) +} + +func (m MockAccountService) GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + args := m.Called(poolAddress, publicKey) + return args.Get(0).([]dataserviceapi.TokenHoldings), args.Error(1) +} + +func (m MockAccountService) GetPoolSwappableVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { + args := m.Called(poolAddress, publicKey) + return args.Get(0).([]dataserviceapi.TokenHoldings), args.Error(1) +} + +func (m MockAccountService) GetPoolSwapQuote(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapQuoteResult, error) { + args := m.Called(amount, from, fromTokenAddress, poolAddress, toTokenAddress) + return args.Get(0).(*models.PoolSwapQuoteResult), args.Error(1) +} + +func (m MockAccountService) PoolSwap(ctx context.Context, amount, from, fromTokenAddress, poolAddress, toTokenAddress string) (*models.PoolSwapResult, error) { + args := m.Called(amount, from, fromTokenAddress, poolAddress, toTokenAddress) + return args.Get(0).(*models.PoolSwapResult), args.Error(1) +} + +func (m MockAccountService) GetSwapFromTokenMaxLimit(ctx context.Context, poolAddress, fromTokenAddress, toTokenAddress, publicKey string) (*models.MaxLimitResult, error) { + args := m.Called(poolAddress, fromTokenAddress, toTokenAddress, publicKey) + return args.Get(0).(*models.MaxLimitResult), args.Error(1) +} From 06a7ddea6fcf14dd9bd9cafd61dfce26797579f0 Mon Sep 17 00:00:00 2001 From: Carlosokumu Date: Thu, 13 Mar 2025 10:34:29 +0300 Subject: [PATCH 22/22] read persisted vouchers for a particular pool --- dev/api.go | 110 ++++++++++++++++++----------------------------------- 1 file changed, 36 insertions(+), 74 deletions(-) diff --git a/dev/api.go b/dev/api.go index b07eb52..125aff3 100644 --- a/dev/api.go +++ b/dev/api.go @@ -36,6 +36,7 @@ const ( defaultVoucherBalance float64 = 500.00 cityPoolAddress string = "0x3b517308D858a47458aD5C8E699697C5dc91Da0F" poolName string = "citypool" + PoolSymbol string = "CTY" ) type Tx struct { @@ -94,10 +95,11 @@ type Voucher struct { } type Pool struct { - name string - address string - vouchers []Voucher - poolLimit map[string]string + Name string `json: "name"` + Symbol string `json: "symbol"` + Address string `json: "address"` + Vouchers []Voucher `json: "voucher"` + PoolLimit map[string]string `json: "poollimit"` } type DevAccountService struct { @@ -128,7 +130,7 @@ func NewDevAccountService(ctx context.Context, ss storage.StorageService) *DevAc txs: make(map[string]Tx), txsTrack: make(map[string]string), autoVoucherValue: make(map[string]int), - pool: Pool{address: cityPoolAddress, name: poolName}, + pool: Pool{Address: cityPoolAddress, Name: poolName}, defaultAccount: zeroAddress, pfx: []byte("__"), } @@ -183,7 +185,7 @@ func (das *DevAccountService) loadAccount(ctx context.Context, pubKey string, v } func (p *Pool) hasVoucher(voucherAddress string) bool { - for _, value := range p.vouchers { + for _, value := range p.Vouchers { if value.Address == voucherAddress { return true } @@ -221,7 +223,7 @@ func (das *DevAccountService) loadPoolInfo(ctx context.Context, name string, v [ return fmt.Errorf("failed to unmarshall pool info: %v", err) } das.pool = pool - logg.InfoCtxf(ctx, "loaded pool info", "name", das.pool.name, "vouchers", das.pool.vouchers) + logg.InfoCtxf(ctx, "loaded pool info", "name", das.pool.Name, "vouchers", das.pool.Vouchers) return nil } @@ -299,6 +301,12 @@ func (das *DevAccountService) WithAutoVoucher(ctx context.Context, symbol string return das } +func (das *DevAccountService) RegisterPool() { + das.pool.Name = poolName + das.pool.Address = cityPoolAddress + das.pool.Symbol = PoolSymbol +} + // TODO: add persistence for vouchers // TODO: set max balance for 0x00 address func (das *DevAccountService) AddVoucher(ctx context.Context, symbol string) error { @@ -383,7 +391,7 @@ func (das *DevAccountService) savePoolInfo(ctx context.Context, pool Pool) error if das.db == nil { return nil } - k := das.prefixKeyFor("pool", pool.name) + k := das.prefixKeyFor("pool", pool.Name) v, err := json.Marshal(pool) if err != nil { return err @@ -468,7 +476,6 @@ func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poo if !ok { return nil, fmt.Errorf("account not found (publickey): %v", from) } - sym, ok := das.vouchersAddress[tokenAddress] if !ok { return nil, fmt.Errorf("voucher address %v not found", tokenAddress) @@ -483,8 +490,8 @@ func (das *DevAccountService) PoolDeposit(ctx context.Context, amount, from, poo return nil, fmt.Errorf("voucher address %v found but does not resolve", tokenAddress) } - das.pool.vouchers = append(das.pool.vouchers, voucher) - das.pool.poolLimit = map[string]string{tokenAddress: amount} + das.pool.Vouchers = append(das.pool.Vouchers, voucher) + das.pool.PoolLimit = map[string]string{tokenAddress: amount} err = das.savePoolInfo(ctx, das.pool) if err != nil { @@ -779,75 +786,31 @@ func (das *DevAccountService) RequestAlias(ctx context.Context, publicKey string } func (das *DevAccountService) FetchTopPools(ctx context.Context) ([]dataserviceapi.PoolDetails, error) { - topPools := []dataserviceapi.PoolDetails{ - { - PoolName: "Kenya ROLA Pool", - PoolSymbol: "ROLA", - PoolContractAdrress: "0x48a953cA5cf5298bc6f6Af3C608351f537AAcb9e", - LimiterAddress: "", - VoucherRegistry: "", - }, - { - PoolName: "Nairobi ROLA Pool", - PoolSymbol: "NAIROBI", - PoolContractAdrress: "0xB0660Ac1Ee3d32ea35bc728D7CA1705Fa5A37528", - LimiterAddress: "", - VoucherRegistry: "", - }, - { - PoolName: "Friends of Kiriba Ecosystem", - PoolSymbol: "FRIENDS", - PoolContractAdrress: "0xC4848263821FA02baB2181910A2eFb9CECb2c21C", - LimiterAddress: "", - VoucherRegistry: "", - }, - { - PoolName: "Resilient Community Waqfs", - PoolSymbol: "REZILIENS", - PoolContractAdrress: "0x1e40951d7a28147D8B4A554C60c42766C92e2Fc6", - LimiterAddress: "", - VoucherRegistry: "", - }, - { - PoolName: "GrE Tech", - PoolSymbol: "GRET", - PoolContractAdrress: "0xb7B9d0A264eD1a8E2418571B7AC5933C79C9c2B8", - LimiterAddress: "", - VoucherRegistry: "", - }, + var topPools []dataserviceapi.PoolDetails + + pool := dataserviceapi.PoolDetails{ + PoolName: das.pool.Name, + PoolSymbol: das.pool.Symbol, + PoolContractAdrress: das.pool.Address, } + // Add the citypool as the main pool + topPools = append(topPools, pool) + return topPools, nil } func (das *DevAccountService) GetPoolSwappableFromVouchers(ctx context.Context, poolAddress, publicKey string) ([]dataserviceapi.TokenHoldings, error) { - swapFromList := []dataserviceapi.TokenHoldings{ - { - ContractAddress: "0xc7B78Ac9ACB9E025C8234621FC515bC58179dEAe", - TokenSymbol: "AMANI", - TokenDecimals: "6", - Balance: "", - }, - { - ContractAddress: "0xF0C3C7581b8b96B59a97daEc8Bd48247cE078674", - TokenSymbol: "AMUA", - TokenDecimals: "6", - Balance: "", - }, - { - ContractAddress: "0x371455a30fc62736145Bd8429Fcc6481186f235F", - TokenSymbol: "BAHARI", - TokenDecimals: "6", - Balance: "", - }, - { - ContractAddress: "0x7cA6113b59c24a880F382C7E12d609a6Eb05246b", - TokenSymbol: "BANGLA", - TokenDecimals: "6", - Balance: "", - }, - } + var swapFromList []dataserviceapi.TokenHoldings + for _, voucher := range das.pool.Vouchers { + swapFromList = append(swapFromList, dataserviceapi.TokenHoldings{ + ContractAddress: voucher.Address, + TokenSymbol: voucher.Symbol, + TokenDecimals: string(defaultDecimals), + Balance: fmt.Sprintf("%f", defaultVoucherBalance), + }) + } return swapFromList, nil } @@ -860,7 +823,6 @@ func (das *DevAccountService) GetPoolSwappableVouchers(ctx context.Context, pool Balance: "", }, } - return swapToList, nil }