Skip to content

Commit

Permalink
wip: still wiring in
Browse files Browse the repository at this point in the history
  • Loading branch information
@abi87
abi87 committed Oct 31, 2022
1 parent 5d86516 commit 66a0d25
Show file tree
Hide file tree
Showing 5 changed files with 24 additions and 225 deletions.
12 changes: 6 additions & 6 deletions service/helper_test.go → backend/cchain/helper_test.go
View file
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
package service
package cchain

import (
"testing"
Expand All @@ -9,35 +9,35 @@ import (
func TestChecksumAddress(t *testing.T) {
t.Run("valid checksum address", func(t *testing.T) {
testAddr := "0x05da63494DfbfF6AA215E074D34aC9A25B616eF2"
addr, ok := ChecksumAddress(testAddr)
addr, ok := checksumAddress(testAddr)
assert.True(t, ok)
assert.Equal(t, testAddr, addr)
})

t.Run("modified checksum address", func(t *testing.T) {
testAddr := "0x05da63494DfbfF6AA215E074D34aC9A25B616ef2"
addr, ok := ChecksumAddress(testAddr)
addr, ok := checksumAddress(testAddr)
assert.True(t, ok)
assert.Equal(t, "0x05da63494DfbfF6AA215E074D34aC9A25B616eF2", addr)
})

t.Run("invalid hex", func(t *testing.T) {
testAddr := "0x05da63494DfbfF6AA215E074D34aC9A25B616eK2"
addr, ok := ChecksumAddress(testAddr)
addr, ok := checksumAddress(testAddr)
assert.False(t, ok)
assert.Equal(t, "", addr)
})

t.Run("invalid length", func(t *testing.T) {
testAddr := "0x05da63494DfbfF6AA215E074D34aC9A25B"
addr, ok := ChecksumAddress(testAddr)
addr, ok := checksumAddress(testAddr)
assert.False(t, ok)
assert.Equal(t, "", addr)
})

t.Run("missing 0x", func(t *testing.T) {
testAddr := "05da63494DfbfF6AA215E074D34aC9A25B616eF2"
addr, ok := ChecksumAddress(testAddr)
addr, ok := checksumAddress(testAddr)
assert.False(t, ok)
assert.Equal(t, "", addr)
})
Expand Down
19 changes: 2 additions & 17 deletions cmd/server/main.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -176,20 +176,7 @@ func main() {
log.Fatal("server asserter init error:", err)
}

cfgToRemote := &service.Config{
Mode: cfg.Mode,
ChainID: big.NewInt(cfg.CChainID),
NetworkID: networkC,
GenesisBlockHash: cfg.GenesisBlockHash,
AvaxAssetID: assetID,
AP5Activation: AP5Activation,
IndexUnknownTokens: cfg.IndexUnknownTokens,
IngestionMode: cfg.IngestionMode,
TokenWhiteList: cfg.TokenWhiteList,
}
handler := configureRouter(
cfgToRemote,
cChainClient,
cfg.Mode,
asserter,
cChainBackend,
Expand Down Expand Up @@ -246,20 +233,18 @@ func validateNetworkName(cfg *config, cChainClient client.Client) error {
}

func configureRouter(
cfgToRemove *service.Config,
clientToRemote client.Client,
mode string,
asserter *asserter.Asserter,
cChainBackend *cchain.Backend,
pChainBackend *pchain.Backend,
cChainAtomicTxBackend *cchainatomictx.Backend,
) http.Handler {
networkService := service.NewNetworkService(cfgToRemove, clientToRemote, pChainBackend)
networkService := service.NewNetworkService(mode, cChainBackend, pChainBackend)
blockService := service.NewBlockService(mode, cChainBackend, pChainBackend)
accountService := service.NewAccountService(mode, cChainBackend, pChainBackend, cChainAtomicTxBackend)
mempoolService := service.NewMempoolService(mode, cChainBackend)
constructionService := service.NewConstructionService(mode, cChainBackend, pChainBackend, cChainAtomicTxBackend)
callService := service.NewCallService(cfgToRemove, clientToRemote)
callService := service.NewCallService(cChainBackend)

return server.NewRouter(
server.NewNetworkAPIController(networkService, asserter),
Expand Down
45 changes: 0 additions & 45 deletions service/helper.go
View file

This file was deleted.

56 changes: 5 additions & 51 deletions service/service_call.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,18 +2,15 @@ package service

import (
"context"
"encoding/json"

"github.com/ava-labs/avalanche-rosetta/client"
cBackend "github.com/ava-labs/avalanche-rosetta/backend/cchain"
"github.com/coinbase/rosetta-sdk-go/server"
"github.com/coinbase/rosetta-sdk-go/types"
"github.com/ethereum/go-ethereum/common"
)

// CallService implements /call/* endpoints
type CallService struct {
config *Config
client client.Client
cChainBackend *cBackend.Backend
}

// GetTransactionReceiptInput is the input to the call
Expand All @@ -23,57 +20,14 @@ type GetTransactionReceiptInput struct {
}

// NewCallService returns a new call servicer
func NewCallService(config *Config, client client.Client) server.CallAPIServicer {
return &CallService{
config: config,
client: client,
}
func NewCallService(cChainBackend *cBackend.Backend) server.CallAPIServicer {
return &CallService{cChainBackend: cChainBackend}
}

// Call implements the /call endpoint.
func (s CallService) Call(
ctx context.Context,
req *types.CallRequest,
) (*types.CallResponse, *types.Error) {
if s.config.IsOfflineMode() {
return nil, ErrUnavailableOffline
}

switch req.Method {
case "eth_getTransactionReceipt":
return s.callGetTransactionReceipt(ctx, req)
default:
return nil, ErrCallInvalidMethod
}
}

func (s CallService) callGetTransactionReceipt(
ctx context.Context,
req *types.CallRequest,
) (*types.CallResponse, *types.Error) {
var input GetTransactionReceiptInput
if err := types.UnmarshalMap(req.Parameters, &input); err != nil {
return nil, WrapError(ErrCallInvalidParams, err)
}

if len(input.TxHash) == 0 {
return nil, WrapError(ErrCallInvalidParams, "tx_hash missing from params")
}

receipt, err := s.client.TransactionReceipt(ctx, common.HexToHash(input.TxHash))
if err != nil {
return nil, WrapError(ErrClientError, err)
}

jsonOutput, err := receipt.MarshalJSON()
if err != nil {
return nil, WrapError(ErrInternalError, err)
}

var receiptMap map[string]interface{}
if err := json.Unmarshal(jsonOutput, &receiptMap); err != nil {
return nil, WrapError(ErrInternalError, err)
}

return &types.CallResponse{Result: receiptMap}, nil
return s.cChainBackend.Call(ctx, req)
}
117 changes: 11 additions & 106 deletions service/service_network.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,16 +2,11 @@ package service

import (
"context"
"math/big"

"github.com/coinbase/rosetta-sdk-go/server"
"github.com/coinbase/rosetta-sdk-go/types"
"github.com/coinbase/rosetta-sdk-go/utils"

"github.com/ava-labs/avalanche-rosetta/client"
"github.com/ava-labs/avalanche-rosetta/constants"
cconstants "github.com/ava-labs/avalanche-rosetta/constants/cchain"
"github.com/ava-labs/avalanche-rosetta/mapper"
cBackend "github.com/ava-labs/avalanche-rosetta/backend/cchain"
)

// NetworkBackend represents a backend that implements /block family of apis for a subset of requests
Expand All @@ -33,25 +28,21 @@ type NetworkBackend interface {

// NetworkService implements all /network endpoints
type NetworkService struct {
config *Config
client client.Client
mode string
cChainBackend *cBackend.Backend
pChainBackend NetworkBackend
genesisBlock *types.Block
}

// NewNetworkService returns a new network servicer
func NewNetworkService(
config *Config,
client client.Client,
mode string,
cChainBackend *cBackend.Backend,
pChainBackend NetworkBackend,
) server.NetworkAPIServicer {
genesisBlock := makeGenesisBlock(config.GenesisBlockHash)

return &NetworkService{
config: config,
client: client,
mode: mode,
cChainBackend: cChainBackend,
pChainBackend: pChainBackend,
genesisBlock: genesisBlock,
}
}

Expand All @@ -62,7 +53,7 @@ func (s *NetworkService) NetworkList(
) (*types.NetworkListResponse, *types.Error) {
return &types.NetworkListResponse{
NetworkIdentifiers: []*types.NetworkIdentifier{
s.config.NetworkID,
s.cChainBackend.NetworkIdentifier(),
s.pChainBackend.NetworkIdentifier(),
},
}, nil
Expand All @@ -73,66 +64,15 @@ func (s *NetworkService) NetworkStatus(
ctx context.Context,
request *types.NetworkRequest,
) (*types.NetworkStatusResponse, *types.Error) {
if s.config.IsOfflineMode() {
if s.mode == ModeOffline {
return nil, ErrUnavailableOffline
}

if s.pChainBackend.ShouldHandleRequest(request) {
return s.pChainBackend.NetworkStatus(ctx, request)
}

// Fetch peers
infoPeers, err := s.client.Peers(ctx)
if err != nil {
return nil, WrapError(ErrClientError, err)
}
peers := mapper.Peers(infoPeers)

// Check if all C/X chains are ready
if err := checkBootstrapStatus(ctx, s.client); err != nil {
if err.Code == ErrNotReady.Code {
return &types.NetworkStatusResponse{
CurrentBlockTimestamp: s.genesisBlock.Timestamp,
CurrentBlockIdentifier: s.genesisBlock.BlockIdentifier,
GenesisBlockIdentifier: s.genesisBlock.BlockIdentifier,
SyncStatus: constants.StageBootstrap,
Peers: peers,
}, nil
}
return nil, err
}

// Fetch the latest block
blockHeader, err := s.client.HeaderByNumber(ctx, nil)
if err != nil {
return nil, WrapError(ErrClientError, err)
}
if blockHeader == nil {
return nil, WrapError(ErrClientError, "latest block not found")
}

// Fetch the genesis block
genesisHeader, err := s.client.HeaderByNumber(ctx, big.NewInt(0))
if err != nil {
return nil, WrapError(ErrClientError, err)
}
if genesisHeader == nil {
return nil, WrapError(ErrClientError, "genesis block not found")
}

return &types.NetworkStatusResponse{
CurrentBlockTimestamp: int64(blockHeader.Time * utils.MillisecondsInSecond),
CurrentBlockIdentifier: &types.BlockIdentifier{
Index: blockHeader.Number.Int64(),
Hash: blockHeader.Hash().String(),
},
GenesisBlockIdentifier: &types.BlockIdentifier{
Index: genesisHeader.Number.Int64(),
Hash: genesisHeader.Hash().String(),
},
SyncStatus: constants.StageSynced,
Peers: peers,
}, nil
return s.cChainBackend.NetworkStatus(ctx, request)
}

// NetworkOptions implements the /network/options endpoint
Expand All @@ -144,40 +84,5 @@ func (s *NetworkService) NetworkOptions(
return s.pChainBackend.NetworkOptions(ctx, request)
}

return &types.NetworkOptionsResponse{
Version: &types.Version{
RosettaVersion: types.RosettaAPIVersion,
NodeVersion: NodeVersion,
MiddlewareVersion: types.String(MiddlewareVersion),
},
Allow: &types.Allow{
OperationStatuses: constants.OperationStatuses,
OperationTypes: cconstants.CChainOps(),
CallMethods: cconstants.CChainCallMethods(),
Errors: Errors,
HistoricalBalanceLookup: true,
},
}, nil
}

func checkBootstrapStatus(ctx context.Context, client client.Client) *types.Error {
cReady, err := client.IsBootstrapped(ctx, constants.CChain.String())
if err != nil {
return WrapError(ErrClientError, err)
}

xReady, err := client.IsBootstrapped(ctx, constants.XChain.String())
if err != nil {
return WrapError(ErrClientError, err)
}

if !cReady {
return WrapError(ErrNotReady, "C-Chain is not ready")
}

if !xReady {
return WrapError(ErrNotReady, "X-Chain is not ready")
}

return nil
return s.cChainBackend.NetworkOptions(ctx, request)
}

0 comments on commit 66a0d25

Please sign in to comment.