release: v1.0.0

internal/chain/chain.go

@@ -0,0 +1,21 @@
+package chain
+
+import (
+	"context"
+	"math/big"
+
+	"github.com/celo-org/celo-blockchain/common"
+	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/grassrootseconomics/celoutils/v3"
+)
+
+type Chain interface {
+	GetBlocks(context.Context, []uint64) ([]types.Block, error)
+	GetBlock(context.Context, uint64) (*types.Block, error)
+	GetLatestBlock(context.Context) (uint64, error)
+	GetTransaction(context.Context, common.Hash) (*types.Transaction, error)
+	GetReceipts(context.Context, *types.Block) ([]types.Receipt, error)
+	GetRevertReason(context.Context, common.Hash, *big.Int) (string, error)
+	Provider() *celoutils.Provider
+	IsArchiveNode() bool
+}

internal/chain/rpc.go

@@ -0,0 +1,139 @@
+package chain
+
+import (
+	"context"
+	"math/big"
+	"net/http"
+	"time"
+
+	"github.com/celo-org/celo-blockchain/common"
+	"github.com/celo-org/celo-blockchain/core/types"
+	"github.com/celo-org/celo-blockchain/rpc"
+	"github.com/grassrootseconomics/celoutils/v3"
+	"github.com/grassrootseconomics/w3-celo"
+	"github.com/grassrootseconomics/w3-celo/module/eth"
+	"github.com/grassrootseconomics/w3-celo/w3types"
+)
+
+type (
+	RPCOpts struct {
+		RPCEndpoint   string
+		ChainID       int64
+		IsArchiveNode bool
+	}
+
+	RPC struct {
+		provider      *celoutils.Provider
+		isArchiveNode bool
+	}
+)
+
+func NewRPCFetcher(o RPCOpts) (Chain, error) {
+	customRPCClient, err := lowTimeoutRPCClient(o.RPCEndpoint)
+	if err != nil {
+		return nil, err
+	}
+
+	chainProvider := celoutils.NewProvider(
+		o.RPCEndpoint,
+		o.ChainID,
+		celoutils.WithClient(customRPCClient),
+	)
+
+	return &RPC{
+		provider:      chainProvider,
+		isArchiveNode: o.IsArchiveNode,
+	}, nil
+}
+
+func lowTimeoutRPCClient(rpcEndpoint string) (*w3.Client, error) {
+	httpClient := &http.Client{
+		Timeout: 10 * time.Second,
+	}
+
+	rpcClient, err := rpc.DialHTTPWithClient(
+		rpcEndpoint,
+		httpClient,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return w3.NewClient(rpcClient), nil
+}
+
+func (c *RPC) GetBlocks(ctx context.Context, blockNumbers []uint64) ([]types.Block, error) {
+	blocksCount := len(blockNumbers)
+	calls := make([]w3types.RPCCaller, blocksCount)
+	blocks := make([]types.Block, blocksCount)
+
+	for i, v := range blockNumbers {
+		calls[i] = eth.BlockByNumber(new(big.Int).SetUint64(v)).Returns(&blocks[i])
+	}
+
+	if err := c.provider.Client.CallCtx(ctx, calls...); err != nil {
+		return nil, err
+	}
+
+	return blocks, nil
+}
+
+func (c *RPC) GetBlock(ctx context.Context, blockNumber uint64) (*types.Block, error) {
+	var block types.Block
+	blockCall := eth.BlockByNumber(new(big.Int).SetUint64(blockNumber)).Returns(&block)
+
+	if err := c.provider.Client.CallCtx(ctx, blockCall); err != nil {
+		return nil, err
+	}
+
+	return &block, nil
+}
+
+func (c *RPC) GetLatestBlock(ctx context.Context) (uint64, error) {
+	var latestBlock big.Int
+	latestBlockCall := eth.BlockNumber().Returns(&latestBlock)
+
+	if err := c.provider.Client.CallCtx(ctx, latestBlockCall); err != nil {
+		return 0, err
+	}
+
+	return latestBlock.Uint64(), nil
+}
+
+func (c *RPC) GetTransaction(ctx context.Context, txHash common.Hash) (*types.Transaction, error) {
+	var transaction types.Transaction
+	if err := c.provider.Client.CallCtx(ctx, eth.Tx(txHash).Returns(&transaction)); err != nil {
+		return nil, err
+	}
+
+	return &transaction, nil
+}
+
+func (c *RPC) GetReceipts(ctx context.Context, block *types.Block) ([]types.Receipt, error) {
+	txCount := len(block.Transactions())
+
+	calls := make([]w3types.RPCCaller, txCount)
+	receipts := make([]types.Receipt, txCount)
+
+	for i, tx := range block.Transactions() {
+		calls[i] = eth.TxReceipt(tx.Hash()).Returns(&receipts[i])
+	}
+
+	if err := c.provider.Client.CallCtx(ctx, calls...); err != nil {
+		return nil, err
+	}
+
+	return receipts, nil
+}
+
+func (c *RPC) GetRevertReason(ctx context.Context, txHash common.Hash, blockNumber *big.Int) (string, error) {
+	return c.provider.SimulateRevertedTx(ctx, txHash, blockNumber)
+}
+
+func (c *RPC) Provider() *celoutils.Provider {
+	return c.provider
+}
+
+func (c *RPC) IsArchiveNode() bool {
+	return c.isArchiveNode
+}