github.com/kotalco/kotal@v0.3.0/clients/ethereum/besu_client_test.go (about)

     1  package ethereum
     2  
     3  import (
     4  	"fmt"
     5  
     6  	ethereumv1alpha1 "github.com/kotalco/kotal/apis/ethereum/v1alpha1"
     7  	sharedAPI "github.com/kotalco/kotal/apis/shared"
     8  	"github.com/kotalco/kotal/controllers/shared"
     9  	. "github.com/onsi/ginkgo/v2"
    10  	. "github.com/onsi/gomega"
    11  
    12  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    13  )
    14  
    15  var _ = Describe("Besu Client", func() {
    16  
    17  	enode := ethereumv1alpha1.Enode("enode://2281549869465d98e90cebc45e1d6834a01465a990add7bcf07a49287e7e66b50ca27f9c70a46190cef7ad746dd5d5b6b9dfee0c9954104c8e9bd0d42758ec58@10.5.0.2:30300")
    18  	coinbase := "0x5A0b54D5dc17e0AadC383d2db43B0a0D3E029c4c"
    19  
    20  	Context("general", func() {
    21  		node := &ethereumv1alpha1.Node{
    22  			ObjectMeta: metav1.ObjectMeta{
    23  				Name: "gneral",
    24  			},
    25  			Spec: ethereumv1alpha1.NodeSpec{
    26  				Client: ethereumv1alpha1.BesuClient,
    27  				StaticNodes: []ethereumv1alpha1.Enode{
    28  					enode,
    29  				},
    30  			},
    31  		}
    32  		client, _ := NewClient(node)
    33  
    34  		It("should return correct home directory", func() {
    35  			Expect(client.HomeDir()).To(Equal(BesuHomeDir))
    36  		})
    37  
    38  		It("should encode static nodes correctly", func() {
    39  			Expect(client.EncodeStaticNodes()).To(Equal(fmt.Sprintf("[\"%s\"]", enode)))
    40  		})
    41  
    42  	})
    43  
    44  	Context("Joining mainnet", func() {
    45  		node := &ethereumv1alpha1.Node{
    46  			ObjectMeta: metav1.ObjectMeta{
    47  				Name: "besu-mainnet-node",
    48  			},
    49  			Spec: ethereumv1alpha1.NodeSpec{
    50  				Client:                   ethereumv1alpha1.BesuClient,
    51  				Network:                  ethereumv1alpha1.MainNetwork,
    52  				Bootnodes:                []ethereumv1alpha1.Enode{enode},
    53  				NodePrivateKeySecretName: "besu-mainnet-nodekey",
    54  				StaticNodes:              []ethereumv1alpha1.Enode{enode},
    55  				P2PPort:                  3333,
    56  				SyncMode:                 ethereumv1alpha1.LightSynchronization,
    57  				Logging:                  sharedAPI.WarnLogs,
    58  				Hosts:                    []string{"whitelisted.host.com"},
    59  				CORSDomains:              []string{"allowed.domain.com"},
    60  				RPC:                      true,
    61  				RPCPort:                  8888,
    62  				RPCAPI: []ethereumv1alpha1.API{
    63  					ethereumv1alpha1.NetworkAPI,
    64  					ethereumv1alpha1.AdminAPI,
    65  					ethereumv1alpha1.DebugAPI,
    66  				},
    67  				Engine:        true,
    68  				EnginePort:    8552,
    69  				JWTSecretName: "jwt-secret",
    70  				WS:            true,
    71  				WSPort:        7777,
    72  				WSAPI: []ethereumv1alpha1.API{
    73  					ethereumv1alpha1.ETHAPI,
    74  					ethereumv1alpha1.TransactionPoolAPI,
    75  				},
    76  				GraphQL:     true,
    77  				GraphQLPort: 9999,
    78  			},
    79  		}
    80  		node.Default()
    81  
    82  		It("should generate correct arguments", func() {
    83  
    84  			client, err := NewClient(node)
    85  
    86  			Expect(err).To(BeNil())
    87  			Expect(client.Args()).To(ContainElements(
    88  				BesuDataPath,
    89  				shared.PathData(client.HomeDir()),
    90  				BesuNatMethod,
    91  				"KUBERNETES",
    92  				BesuNetwork,
    93  				ethereumv1alpha1.MainNetwork,
    94  				BesuLogging,
    95  				"WARN",
    96  				BesuNodePrivateKey,
    97  				fmt.Sprintf("%s/nodekey", shared.PathSecrets(client.HomeDir())),
    98  				BesuStaticNodesFile,
    99  				fmt.Sprintf("%s/static-nodes.json", shared.PathConfig(client.HomeDir())),
   100  				BesuBootnodes,
   101  				string(enode),
   102  				BesuP2PPort,
   103  				"3333",
   104  				BesuSyncMode,
   105  				string(ethereumv1alpha1.LightSynchronization),
   106  				BesuRPCHTTPEnabled,
   107  				BesuRPCHTTPHost,
   108  				"0.0.0.0",
   109  				BesuRPCHTTPPort,
   110  				"8888",
   111  				BesuRPCHTTPAPI,
   112  				"NET,ADMIN,DEBUG",
   113  				BesuEngineRpcEnabled,
   114  				BesuEngineHostAllowList,
   115  				"whitelisted.host.com",
   116  				BesuEngineRpcPort,
   117  				"8552",
   118  				BesuEngineJwtSecret,
   119  				fmt.Sprintf("%s/jwt.secret", shared.PathSecrets(client.HomeDir())),
   120  				BesuRPCWSEnabled,
   121  				BesuRPCWSHost,
   122  				"0.0.0.0",
   123  				BesuRPCWSPort,
   124  				"7777",
   125  				BesuRPCWSAPI,
   126  				"ETH,TXPOOL",
   127  				BesuGraphQLHTTPEnabled,
   128  				BesuGraphQLHTTPHost,
   129  				"0.0.0.0",
   130  				BesuGraphQLHTTPPort,
   131  				"9999",
   132  				BesuHostAllowlist,
   133  				"whitelisted.host.com",
   134  				BesuRPCHTTPCorsOrigins,
   135  				"allowed.domain.com",
   136  				BesuGraphQLHTTPCorsOrigins,
   137  				"allowed.domain.com",
   138  			))
   139  		})
   140  
   141  	})
   142  
   143  	Context("miner in private PoW network", func() {
   144  		node := &ethereumv1alpha1.Node{
   145  			ObjectMeta: metav1.ObjectMeta{
   146  				Name: "besu-pow-node",
   147  			},
   148  			Spec: ethereumv1alpha1.NodeSpec{
   149  				Genesis: &ethereumv1alpha1.Genesis{
   150  					ChainID:   12345,
   151  					NetworkID: 12345,
   152  					Ethash:    &ethereumv1alpha1.Ethash{},
   153  				},
   154  				Client:                   ethereumv1alpha1.BesuClient,
   155  				Miner:                    true,
   156  				NodePrivateKeySecretName: "besu-pow-nodekey",
   157  				Coinbase:                 sharedAPI.EthereumAddress(coinbase),
   158  			},
   159  		}
   160  		node.Default()
   161  
   162  		It("should generate correct arguments", func() {
   163  
   164  			client, err := NewClient(node)
   165  
   166  			Expect(err).To(BeNil())
   167  			Expect(client.Args()).NotTo(ContainElements(BesuNetwork))
   168  			Expect(client.Args()).To(ContainElements(
   169  				BesuGenesisFile,
   170  				fmt.Sprintf("%s/genesis.json", shared.PathConfig(client.HomeDir())),
   171  				BesuMinerEnabled,
   172  				BesuMinerCoinbase,
   173  				coinbase,
   174  				BesuNetworkID,
   175  				"12345",
   176  				BesuDiscoveryEnabled,
   177  				"false",
   178  			))
   179  		})
   180  
   181  	})
   182  
   183  	Context("signer in private PoA network", func() {
   184  		node := &ethereumv1alpha1.Node{
   185  			ObjectMeta: metav1.ObjectMeta{
   186  				Name: "besu-poa-node",
   187  			},
   188  			Spec: ethereumv1alpha1.NodeSpec{
   189  				Genesis: &ethereumv1alpha1.Genesis{
   190  					ChainID:   12345,
   191  					NetworkID: 12345,
   192  					Clique: &ethereumv1alpha1.Clique{
   193  						Signers: []sharedAPI.EthereumAddress{
   194  							"0xcF2C3fB8F36A863FD1A8c72E2473f81744B4CA6C",
   195  							"0x1990E5760d9f8Ae0ec55dF8B0819C77e59846Ff2",
   196  							"0xB87c1c66b36D98D1A74a9875EbA12c001e0bcEda",
   197  						},
   198  					},
   199  				},
   200  				Client:                   ethereumv1alpha1.BesuClient,
   201  				Miner:                    true,
   202  				NodePrivateKeySecretName: "besu-poa-nodekey",
   203  				Coinbase:                 sharedAPI.EthereumAddress(coinbase),
   204  			},
   205  		}
   206  		node.Default()
   207  
   208  		It("should generate correct arguments", func() {
   209  
   210  			client, err := NewClient(node)
   211  
   212  			Expect(err).To(BeNil())
   213  			Expect(client.Args()).NotTo(ContainElements(BesuNetwork))
   214  			Expect(client.Args()).To(ContainElements(
   215  				BesuGenesisFile,
   216  				fmt.Sprintf("%s/genesis.json", shared.PathConfig(client.HomeDir())),
   217  				BesuMinerEnabled,
   218  				BesuMinerCoinbase,
   219  				coinbase,
   220  				BesuNetworkID,
   221  				"12345",
   222  				BesuDiscoveryEnabled,
   223  				"false",
   224  			))
   225  		})
   226  
   227  	})
   228  
   229  	Context("validator in private IBFT2 network", func() {
   230  		node := &ethereumv1alpha1.Node{
   231  			ObjectMeta: metav1.ObjectMeta{
   232  				Name: "besu-ibft2-node",
   233  			},
   234  			Spec: ethereumv1alpha1.NodeSpec{
   235  				Genesis: &ethereumv1alpha1.Genesis{
   236  					ChainID:   12345,
   237  					NetworkID: 12345,
   238  					IBFT2: &ethereumv1alpha1.IBFT2{
   239  						Validators: []sharedAPI.EthereumAddress{
   240  							"0xcF2C3fB8F36A863FD1A8c72E2473f81744B4CA6C",
   241  							"0x1990E5760d9f8Ae0ec55dF8B0819C77e59846Ff2",
   242  							"0xB87c1c66b36D98D1A74a9875EbA12c001e0bcEda",
   243  						},
   244  					},
   245  				},
   246  				Client:                   ethereumv1alpha1.BesuClient,
   247  				Miner:                    true,
   248  				NodePrivateKeySecretName: "besu-ibft2-nodekey",
   249  				Coinbase:                 sharedAPI.EthereumAddress(coinbase),
   250  			},
   251  		}
   252  		node.Default()
   253  
   254  		It("should generate correct arguments", func() {
   255  
   256  			client, err := NewClient(node)
   257  
   258  			Expect(err).To(BeNil())
   259  			Expect(client.Args()).NotTo(ContainElements(BesuNetwork))
   260  			Expect(client.Args()).To(ContainElements(
   261  				BesuGenesisFile,
   262  				fmt.Sprintf("%s/genesis.json", shared.PathConfig(client.HomeDir())),
   263  				BesuMinerEnabled,
   264  				BesuMinerCoinbase,
   265  				coinbase,
   266  				BesuNetworkID,
   267  				"12345",
   268  				BesuDiscoveryEnabled,
   269  				"false",
   270  			))
   271  		})
   272  
   273  	})
   274  
   275  })