Define base transfer support

Author: zivkovicmilos

broadcast.go

@@ -0,0 +1,31 @@
+package faucet
+
+import (
+	"fmt"
+
+	"github.com/gnolang/faucet/client"
+	"github.com/gnolang/gno/tm2/pkg/std"
+)
+
+// broadcastTransaction broadcasts the transaction using a COMMIT send
+func broadcastTransaction(client client.Client, tx *std.Tx) error {
+	// Send the transaction.
+	// NOTE: Commit sends are temporary. Once
+	// there is support for event indexing, this
+	// call will change to a sync send
+	response, err := client.SendTransactionCommit(tx)
+	if err != nil {
+		return fmt.Errorf("unable to send transaction, %w", err)
+	}
+
+	// Check the errors
+	if response.CheckTx.IsErr() {
+		return fmt.Errorf("transaction failed initial validation, %w", response.CheckTx.Error)
+	}
+
+	if response.DeliverTx.IsErr() {
+		return fmt.Errorf("transaction failed during execution, %w", response.DeliverTx.Error)
+	}
+
+	return nil
+}

client/client.go

@@ -0,0 +1,25 @@
+package client
+
+import (
+	coreTypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+)
+
+// Client defines the TM2 client functionality
+type Client interface {
+	// Account methods //
+
+	// GetAccount fetches the account if it has been initialized
+	GetAccount(address crypto.Address) (std.Account, error)
+
+	// Transaction methods //
+
+	// SendTransactionSync sends the specified transaction to the network,
+	// and does not wait for it to be committed to the chain
+	SendTransactionSync(tx *std.Tx) (*coreTypes.ResultBroadcastTx, error)
+
+	// SendTransactionCommit sends the specified transaction to the network,
+	// and wait for it to be committed to the chain
+	SendTransactionCommit(tx *std.Tx) (*coreTypes.ResultBroadcastTxCommit, error)
+}

client/http/http.go

@@ -0,0 +1,58 @@
+package http
+
+import (
+	"fmt"
+
+	"github.com/gnolang/gno/tm2/pkg/amino"
+	rpcClient "github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
+	coreTypes "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/std"
+)
+
+// Client is the TM2 HTTP client
+type Client struct {
+	client rpcClient.Client
+}
+
+// NewClient creates a new TM2 HTTP client
+func NewClient(remote string) *Client {
+	return &Client{
+		client: rpcClient.NewHTTP(remote, ""),
+	}
+}
+
+func (c *Client) GetAccount(address crypto.Address) (std.Account, error) {
+	path := fmt.Sprintf("auth/accounts/%s", address.String())
+
+	queryResponse, err := c.client.ABCIQuery(path, []byte{})
+	if err != nil {
+		return nil, fmt.Errorf("unable to execute ABCI query, %w", err)
+	}
+
+	var queryData struct{ BaseAccount std.BaseAccount }
+
+	if err := amino.UnmarshalJSON(queryResponse.Response.Data, &queryData); err != nil {
+		return nil, err
+	}
+
+	return &queryData.BaseAccount, nil
+}
+
+func (c *Client) SendTransactionSync(tx *std.Tx) (*coreTypes.ResultBroadcastTx, error) {
+	aminoTx, err := amino.Marshal(tx)
+	if err != nil {
+		return nil, fmt.Errorf("unable to marshal transaction, %w", err)
+	}
+
+	return c.client.BroadcastTxSync(aminoTx)
+}
+
+func (c *Client) SendTransactionCommit(tx *std.Tx) (*coreTypes.ResultBroadcastTxCommit, error) {
+	aminoTx, err := amino.Marshal(tx)
+	if err != nil {
+		return nil, fmt.Errorf("unable to marshal transaction, %w", err)
+	}
+
+	return c.client.BroadcastTxCommit(aminoTx)
+}

cmd/root/root.go

@@ -87,6 +87,20 @@ func registerFlags(cfg *faucetCfg, fs *flag.FlagSet) {
 		"the chain ID associated with the remote Gno chain",
 	)
 
+	fs.StringVar(
+		&cfg.Mnemonic,
+		"mnemonic",
+		config.DefaultMnemonic,
+		"the mnemonic for faucet keys",
+	)
+
+	fs.Uint64Var(
+		&cfg.NumAccounts,
+		"num-accounts",
+		config.DefaultNumAccounts,
+		"the number of faucet accounts, based on the mnemonic",
+	)
+
 	fs.StringVar(
 		&cfg.SendAmount,
 		"send-amount",

config/config.go

@@ -2,7 +2,10 @@ package config
 
 import (
 	"errors"
+	"fmt"
 	"regexp"
+
+	"github.com/gnolang/gno/tm2/pkg/crypto/bip39"
 )
 
 const (
@@ -12,6 +15,8 @@ const (
 	DefaultSendAmount    = "1000000ugnot"
 	DefaultGasFee        = "1000000ugnot"
 	DefaultGasWanted     = "100000"
+	DefaultMnemonic      = "source bonus chronic canvas draft south burst lottery vacant surface solve popular case indicate oppose farm nothing bullet exhibit title speed wink action roast"
+	DefaultNumAccounts   = uint64(1)
 )
 
 var (
@@ -33,6 +38,13 @@ type Config struct {
 	// The chain ID associated with the remote Gno chain
 	ChainID string `toml:"chain_id"`
 
+	// The mnemonic for the faucet
+	Mnemonic string `toml:"mnemonic"`
+
+	// The number of faucet accounts,
+	// based on the mnemonic (account 0, index x)
+	NumAccounts uint64 `toml:"num_accounts"`
+
 	// The static send amount (native currency).
 	// Format should be: <AMOUNT>ugnot
 	SendAmount string `toml:"send_amount"`
@@ -58,6 +70,8 @@ func DefaultConfig() *Config {
 		SendAmount:    DefaultSendAmount,
 		GasFee:        DefaultGasFee,
 		GasWanted:     DefaultGasWanted,
+		Mnemonic:      DefaultMnemonic,
+		NumAccounts:   DefaultNumAccounts,
 		CORSConfig:    DefaultCORSConfig(),
 	}
 }
@@ -94,5 +108,15 @@ func ValidateConfig(config *Config) error {
 		return errors.New("invalid gas wanted")
 	}
 
+	// validate the mnemonic is bip39-compliant
+	if !bip39.IsMnemonicValid(config.Mnemonic) {
+		return fmt.Errorf("invalid mnemonic, %s", config.Mnemonic)
+	}
+
+	// validate at least one faucet account is set
+	if config.NumAccounts < 1 {
+		return errors.New("invalid number of faucet accounts")
+	}
+
 	return nil
 }

estimate/estimate.go

@@ -4,8 +4,8 @@ import "github.com/gnolang/gno/tm2/pkg/std"
 
 // Estimator defines the transaction gas estimator
 type Estimator interface {
-	// EstimateGasFee estimates the optimal gas fee for the specified transaction
-	EstimateGasFee(tx std.Tx) std.Coins
+	// EstimateGasFee estimates the current network gas fee for transactions
+	EstimateGasFee() std.Coin
 
 	// EstimateGasWanted estimates the optimal gas wanted for the specified transaction
 	EstimateGasWanted(tx std.Tx) int64

estimate/static/static.go

@@ -6,19 +6,19 @@ import (
 
 // Estimator is a static gas estimator (returns static values)
 type Estimator struct {
-	gasFee    std.Coins
+	gasFee    std.Coin
 	gasWanted int64
 }
 
 // New creates a new static gas estimator
-func New(gasFee std.Coins, gasWanted int64) *Estimator {
+func New(gasFee std.Coin, gasWanted int64) *Estimator {
 	return &Estimator{
 		gasFee:    gasFee,
 		gasWanted: gasWanted,
 	}
 }
 
-func (e Estimator) EstimateGasFee(_ std.Tx) std.Coins {
+func (e Estimator) EstimateGasFee() std.Coin {
 	return e.gasFee
 }
 

faucet.go

@@ -7,6 +7,8 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/gnolang/faucet/client"
+	tm2Client "github.com/gnolang/faucet/client/http"
 	"github.com/gnolang/faucet/config"
 	"github.com/gnolang/faucet/estimate"
 	"github.com/gnolang/faucet/log"
@@ -20,12 +22,15 @@ import (
 type Faucet struct {
 	estimator estimate.Estimator // gas pricing estimations
 	logger    log.Logger         // log feedback
+	client    client.Client      // TM2 client
 
 	mux *chi.Mux // HTTP routing
 
 	config      *config.Config // faucet configuration
 	middlewares []Middleware   // request middlewares
 	handlers    []Handler      // request handlers
+
+	keyring keyring // the faucet keyring
 }
 
 // NewFaucet creates a new instance of the Gno faucet server
@@ -35,21 +40,39 @@ func NewFaucet(estimator estimate.Estimator, opts ...Option) (*Faucet, error) {
 		logger:      nul.New(),
 		config:      config.DefaultConfig(),
 		middlewares: nil, // no middlewares by default
-		handlers:    nil, // TODO single default handler
 
 		mux: chi.NewMux(),
 	}
 
+	// Set the single default HTTP handler
+	f.handlers = []Handler{
+		{
+			"/",
+			f.defaultHTTPHandler,
+		},
+	}
+
 	// Apply the options
 	for _, opt := range opts {
 		opt(f)
 	}
 
+	// Set the faucet client
+	f.client = tm2Client.NewClient(f.config.Remote)
+
 	// Validate the configuration
 	if err := config.ValidateConfig(f.config); err != nil {
 		return nil, fmt.Errorf("invalid configuration, %w", err)
 	}
 
+	// Generate the keyring
+	keyring, err := newKeyring(f.config.Mnemonic, f.config.NumAccounts)
+	if err != nil {
+		return nil, fmt.Errorf("unable to generate keyring, %w", err)
+	}
+
+	f.keyring = keyring
+
 	// Set up the CORS middleware
 	if f.config.CORSConfig != nil {
 		corsMiddleware := cors.New(cors.Options{