275 lines
8.0 KiB
Go
275 lines
8.0 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"time"
|
|
|
|
"git.grassecon.net/urdt/ussd/config"
|
|
"git.grassecon.net/urdt/ussd/internal/models"
|
|
"github.com/grassrootseconomics/eth-custodial/pkg/api"
|
|
)
|
|
|
|
var (
|
|
okResponse api.OKResponse
|
|
errResponse api.ErrResponse
|
|
)
|
|
|
|
type AccountServiceInterface interface {
|
|
CheckBalance(ctx context.Context, publicKey string) (*models.BalanceResponse, error)
|
|
CreateAccount(ctx context.Context) (*api.OKResponse, error)
|
|
CheckAccountStatus(ctx context.Context, trackingId string) (*models.TrackStatusResponse, error)
|
|
TrackAccountStatus(ctx context.Context, publicKey string) (*api.OKResponse, error)
|
|
FetchVouchers(ctx context.Context, publicKey string) (*models.VoucherHoldingResponse, error)
|
|
}
|
|
|
|
type AccountService struct {
|
|
}
|
|
|
|
type TestAccountService struct {
|
|
}
|
|
|
|
// Parameters:
|
|
// - trackingId: A unique identifier for the account.This should be obtained from a previous call to
|
|
// CreateAccount or a similar function that returns an AccountResponse. The `trackingId` field in the
|
|
// AccountResponse struct can be used here to check the account status during a transaction.
|
|
//
|
|
// Returns:
|
|
// - string: The status of the transaction as a string. If there is an error during the request or processing, this will be an empty string.
|
|
// - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
|
|
// If no error occurs, this will be nil
|
|
func (as *AccountService) CheckAccountStatus(ctx context.Context, trackingId string) (*models.TrackStatusResponse, error) {
|
|
resp, err := http.Get(config.BalanceURL + trackingId)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var trackResp models.TrackStatusResponse
|
|
err = json.Unmarshal(body, &trackResp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &trackResp, nil
|
|
|
|
}
|
|
|
|
func (as *AccountService) TrackAccountStatus(ctx context.Context, publicKey string) (*api.OKResponse, error) {
|
|
var err error
|
|
// Construct the URL with the path parameter
|
|
url := fmt.Sprintf("%s/%s", config.TrackURL, publicKey)
|
|
req, err := http.NewRequest("GET", url, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-GE-KEY", "xd")
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
errResponse.Description = err.Error()
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode >= http.StatusBadRequest {
|
|
err := json.Unmarshal([]byte(body), &errResponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return nil, errors.New(errResponse.Description)
|
|
}
|
|
err = json.Unmarshal([]byte(body), &okResponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(okResponse.Result) == 0 {
|
|
return nil, errors.New("Empty api result")
|
|
}
|
|
return &okResponse, nil
|
|
|
|
}
|
|
|
|
// CheckBalance retrieves the balance for a given public key from the custodial balance API endpoint.
|
|
// Parameters:
|
|
// - publicKey: The public key associated with the account whose balance needs to be checked.
|
|
func (as *AccountService) CheckBalance(ctx context.Context, publicKey string) (*models.BalanceResponse, error) {
|
|
resp, err := http.Get(config.BalanceURL + publicKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var balanceResp models.BalanceResponse
|
|
err = json.Unmarshal(body, &balanceResp)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &balanceResp, nil
|
|
}
|
|
|
|
// CreateAccount creates a new account in the custodial system.
|
|
// Returns:
|
|
// - *models.AccountResponse: A pointer to an AccountResponse struct containing the details of the created account.
|
|
// If there is an error during the request or processing, this will be nil.
|
|
// - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
|
|
// If no error occurs, this will be nil.
|
|
func (as *AccountService) CreateAccount(ctx context.Context) (*api.OKResponse, error) {
|
|
var err error
|
|
|
|
// Create a new request
|
|
req, err := http.NewRequest("POST", config.CreateAccountURL, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-GE-KEY", "xd")
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
errResponse.Description = err.Error()
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if resp.StatusCode >= http.StatusBadRequest {
|
|
err := json.Unmarshal([]byte(body), &errResponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return nil, errors.New(errResponse.Description)
|
|
}
|
|
err = json.Unmarshal([]byte(body), &okResponse)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if len(okResponse.Result) == 0 {
|
|
return nil, errors.New("Empty api result")
|
|
}
|
|
return &okResponse, nil
|
|
}
|
|
|
|
// FetchVouchers retrieves the token holdings for a given public key from the custodial holdings API endpoint
|
|
// Parameters:
|
|
// - publicKey: The public key associated with the account.
|
|
func (as *AccountService) FetchVouchers(ctx context.Context, publicKey string) (*models.VoucherHoldingResponse, error) {
|
|
file, err := os.Open("sample_tokens.json")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer file.Close()
|
|
var holdings models.VoucherHoldingResponse
|
|
|
|
if err := json.NewDecoder(file).Decode(&holdings); err != nil {
|
|
return nil, err
|
|
}
|
|
return &holdings, nil
|
|
}
|
|
|
|
func (tas *TestAccountService) CreateAccount(ctx context.Context) (*api.OKResponse, error) {
|
|
return &api.OKResponse{
|
|
Ok: true,
|
|
Description: "Account creation request received successfully",
|
|
Result: map[string]any{"publicKey": "0x48ADca309b5085852207FAaf2816eD72B52F527C", "trackingId": "28ebe84d-b925-472c-87ae-bbdfa1fb97be"},
|
|
}, nil
|
|
|
|
}
|
|
|
|
func (tas *TestAccountService) CheckBalance(ctx context.Context, publicKey string) (*models.BalanceResponse, error) {
|
|
balanceResponse := &models.BalanceResponse{
|
|
Ok: true,
|
|
Result: struct {
|
|
Balance string `json:"balance"`
|
|
Nonce json.Number `json:"nonce"`
|
|
}{
|
|
Balance: "0.003 CELO",
|
|
Nonce: json.Number("0"),
|
|
},
|
|
}
|
|
return balanceResponse, nil
|
|
}
|
|
|
|
func (tas *TestAccountService) TrackAccountStatus(ctx context.Context, publicKey string) (*api.OKResponse, error) {
|
|
return &api.OKResponse{
|
|
Ok: true,
|
|
Description: "Account creation succeeded",
|
|
Result: map[string]any{
|
|
"active": true,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
func (tas *TestAccountService) CheckAccountStatus(ctx context.Context, trackingId string) (*models.TrackStatusResponse, error) {
|
|
trackResponse := &models.TrackStatusResponse{
|
|
Ok: true,
|
|
Result: struct {
|
|
Transaction struct {
|
|
CreatedAt time.Time "json:\"createdAt\""
|
|
Status string "json:\"status\""
|
|
TransferValue json.Number "json:\"transferValue\""
|
|
TxHash string "json:\"txHash\""
|
|
TxType string "json:\"txType\""
|
|
}
|
|
}{
|
|
Transaction: models.Transaction{
|
|
CreatedAt: time.Now(),
|
|
Status: "SUCCESS",
|
|
TransferValue: json.Number("0.5"),
|
|
TxHash: "0x123abc456def",
|
|
TxType: "transfer",
|
|
},
|
|
},
|
|
}
|
|
return trackResponse, nil
|
|
}
|
|
|
|
func (tas *TestAccountService) FetchVouchers(ctx context.Context, publicKey string) (*models.VoucherHoldingResponse, error) {
|
|
return &models.VoucherHoldingResponse{
|
|
Ok: true,
|
|
Result: struct {
|
|
Holdings []struct {
|
|
ContractAddress string `json:"contractAddress"`
|
|
TokenSymbol string `json:"tokenSymbol"`
|
|
TokenDecimals string `json:"tokenDecimals"`
|
|
Balance string `json:"balance"`
|
|
} `json:"holdings"`
|
|
}{
|
|
Holdings: []struct {
|
|
ContractAddress string `json:"contractAddress"`
|
|
TokenSymbol string `json:"tokenSymbol"`
|
|
TokenDecimals string `json:"tokenDecimals"`
|
|
Balance string `json:"balance"`
|
|
}{
|
|
{
|
|
ContractAddress: "0x6CC75A06ac72eB4Db2eE22F781F5D100d8ec03ee",
|
|
TokenSymbol: "SRF",
|
|
TokenDecimals: "6",
|
|
Balance: "2745987",
|
|
},
|
|
},
|
|
},
|
|
}, nil
|
|
}
|