add mock

benchmark/benchmark_test.go

-package main_test
+package benchmark_test
 
 import (
 	"fmt"
+	"math"
 
 	"testing"
 )
@@ -22,3 +23,95 @@ func BenchmarkHello(b *testing.B) {
 	//b.StopTimer()
 	//b.Logf("end time: %s \n", time.Now())
 }
+
+func BenchmarkCalculate(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Calculate(2)
+	}
+}
+
+// Calculate returns x + 2.
+func Calculate(x int) (result int) {
+	result = x + 2
+	return result
+}
+
+func primeNumbers(max int) []int {
+	var primes []int
+
+	for i := 2; i < max; i++ {
+		isPrime := true
+
+		for j := 2; j <= int(math.Sqrt(float64(i))); j++ {
+			if i%j == 0 {
+				isPrime = false
+				break
+			}
+		}
+
+		if isPrime {
+			primes = append(primes, i)
+		}
+	}
+
+	return primes
+}
+
+var num = 1000
+
+// func BenchmarkPrimeNumbers(b *testing.B) {
+// 	for i := 0; i < b.N; i++ {
+// 		primeNumbers(num)
+// 	}
+// }
+
+var table = []struct {
+	input int
+}{
+	{input: 100},
+	{input: 1000},
+	{input: 74382},
+	{input: 382399},
+}
+
+func BenchmarkPrimeNumbers(b *testing.B) {
+	for _, v := range table {
+		b.Run(fmt.Sprintf("input_size_%d", v.input), func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				//primeNumbers(v.input)
+				sieveOfEratosthenes(v.input)
+			}
+		})
+	}
+}
+
+func sieveOfEratosthenes(max int) []int {
+	b := make([]bool, max)
+
+	var primes []int
+
+	for i := 2; i < max; i++ {
+		if b[i] {
+			continue
+		}
+
+		primes = append(primes, i)
+
+		for k := i * i; k < max; k += i {
+			b[k] = true
+		}
+	}
+
+	return primes
+}
+
+// main_test.go
+func BenchmarkSieveOfErastosthenes(b *testing.B) {
+	for _, v := range table {
+		b.Run(fmt.Sprintf("input_size_%d", v.input), func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				sieveOfEratosthenes(v.input)
+			}
+		})
+	}
+}

benchmark/grcp-tx_test.go

-package main_test
+package benchmark_test
 
 import (
 	"bytes"

benchmark/grpc-queue-tx_test.go

-package main
+package benchmark
 
 import (
 	"bytes"

benchmark/hw_mock.go

+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1 (interfaces: GreeterClient)
+
+// Package mock_v1 is a generated GoMock package.
+package benchmark
+
+import (
+	context "context"
+	reflect "reflect"
+
+	ringv1 "github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1"
+	gomock "github.com/golang/mock/gomock"
+	grpc "google.golang.org/grpc"
+)
+
+// MockGreeterClient is a mock of GreeterClient interface.
+type MockGreeterClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockGreeterClientMockRecorder
+}
+
+// MockGreeterClientMockRecorder is the mock recorder for MockGreeterClient.
+type MockGreeterClientMockRecorder struct {
+	mock *MockGreeterClient
+}
+
+// NewMockGreeterClient creates a new mock instance.
+func NewMockGreeterClient(ctrl *gomock.Controller) *MockGreeterClient {
+	mock := &MockGreeterClient{ctrl: ctrl}
+	mock.recorder = &MockGreeterClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockGreeterClient) EXPECT() *MockGreeterClientMockRecorder {
+	return m.recorder
+}
+
+// SayHello mocks base method.
+func (m *MockGreeterClient) SayHello(arg0 context.Context, arg1 *ringv1.HelloRequest, arg2 ...grpc.CallOption) (*ringv1.HelloReply, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SayHello", varargs...)
+	ret0, _ := ret[0].(*ringv1.HelloReply)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SayHello indicates an expected call of SayHello.
+func (mr *MockGreeterClientMockRecorder) SayHello(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SayHello", reflect.TypeOf((*MockGreeterClient)(nil).SayHello), varargs...)
+}

benchmark/main.go

-package main
+package benchmark
 
 import (
 	"bytes"

benchmark/mock_test.go

+package benchmark
+
+import (
+	"fmt"
+	"testing"
+
+	ring "github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1"
+	"github.com/golang/mock/gomock"
+	"google.golang.org/protobuf/proto"
+)
+
+//mockgen github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1 GreeterClient > benchmark/hw_mock.go
+//RingService
+//mockgen github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1  RingServiceClient > benchmark/ring_mock.go
+
+func TestSendEmptyMsg(t *testing.T) {
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGreeterClient := NewMockRingServiceClient(ctrl)
+
+	mockGreeterClient.EXPECT().SendEmptyMsg(gomock.Any(), gomock.Any()).Return(&ring.EmptyResponse{}, nil).AnyTimes()
+	// gomock.Any(), // expect any value for first parameter
+	// gomock.Any(), // expect any value for second parameter
+
+}
+
+type rpcMsg struct {
+	msg proto.Message
+}
+
+func (r *rpcMsg) Matches(msg interface{}) bool {
+	m, ok := msg.(proto.Message)
+	if !ok {
+		return false
+	}
+	return proto.Equal(m, r.msg)
+}
+
+func (r *rpcMsg) String() string {
+	return fmt.Sprintf("is %s", r.msg)
+}
+
+func TestHelloWorld(t *testing.T) {
+
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockGreeterClient := NewMockGreeterClient(ctrl)
+
+	req := &ring.HelloRequest{Name: "unit_test"}
+
+	mockGreeterClient.EXPECT().SayHello(
+		gomock.Any(),      // expect any value for first parameter
+		&rpcMsg{msg: req}, // expect any value for second parameter
+	).Return(&ring.HelloReply{Name: "Mocked RPC"}, nil).AnyTimes()
+}
+
+func BenchmarkHelloWorld(b *testing.B) {
+
+	ctrl := gomock.NewController(b)
+	defer ctrl.Finish()
+
+	mockGreeterClient := NewMockGreeterClient(ctrl)
+
+	req := &ring.HelloRequest{Name: "unit_test"}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+
+		mockGreeterClient.EXPECT().SayHello(
+			gomock.Any(),      // expect any value for first parameter
+			&rpcMsg{msg: req}, // expect any value for second parameter).Return(101)
+		).Return(&ring.HelloReply{Name: "Mocked RPC"}, nil).AnyTimes()
+
+	}
+}

benchmark/new.txt

+goos: linux
+goarch: amd64
+pkg: github.com/CaduceusMetaverseProtocol/metaprotocol/benchmark
+cpu: Intel(R) Xeon(R) Platinum 8275CL CPU @ 3.00GHz
+BenchmarkPrimeNumbers/input_size_100-8         	 3176238	       376.2 ns/op	     616 B/op	       7 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	 3196476	       375.8 ns/op	     616 B/op	       7 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	 3165849	       375.2 ns/op	     616 B/op	       7 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	 3180127	       374.9 ns/op	     616 B/op	       7 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	 3191452	       374.7 ns/op	     616 B/op	       7 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	  486660	      2332 ns/op	    5112 B/op	      10 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	  485665	      2356 ns/op	    5112 B/op	      10 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	  500113	      2366 ns/op	    5112 B/op	      10 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	  494041	      2338 ns/op	    5112 B/op	      10 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	  487268	      2358 ns/op	    5112 B/op	      10 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	    4917	    228584 ns/op	  341241 B/op	      19 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	    4910	    228502 ns/op	  341241 B/op	      19 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	    4935	    227803 ns/op	  341241 B/op	      19 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	    4903	    227836 ns/op	  341241 B/op	      19 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	    5020	    230502 ns/op	  341241 B/op	      19 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	     988	   1190875 ns/op	 1545468 B/op	      24 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	    1030	   1187270 ns/op	 1545467 B/op	      24 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	    1014	   1168560 ns/op	 1545466 B/op	      24 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	     998	   1178405 ns/op	 1545466 B/op	      24 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	     994	   1181863 ns/op	 1545469 B/op	      24 allocs/op
+PASS
+ok  	github.com/CaduceusMetaverseProtocol/metaprotocol/benchmark	26.125s

benchmark/old.txt

+goos: linux
+goarch: amd64
+pkg: github.com/CaduceusMetaverseProtocol/metaprotocol/benchmark
+cpu: Intel(R) Xeon(R) Platinum 8275CL CPU @ 3.00GHz
+BenchmarkPrimeNumbers/input_size_100-8         	  489702	      2260 ns/op	     504 B/op	       6 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	  502465	      2256 ns/op	     504 B/op	       6 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	  503593	      2265 ns/op	     504 B/op	       6 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	  497701	      2253 ns/op	     504 B/op	       6 allocs/op
+BenchmarkPrimeNumbers/input_size_100-8         	  500527	      2272 ns/op	     504 B/op	       6 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	   25257	     47309 ns/op	    4088 B/op	       9 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	   25201	     47525 ns/op	    4088 B/op	       9 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	   25087	     47352 ns/op	    4088 B/op	       9 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	   25311	     47245 ns/op	    4088 B/op	       9 allocs/op
+BenchmarkPrimeNumbers/input_size_1000-8        	   25254	     47425 ns/op	    4088 B/op	       9 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	      74	  15787618 ns/op	  259320 B/op	      18 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	      75	  15795189 ns/op	  259320 B/op	      18 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	      75	  15791397 ns/op	  259320 B/op	      18 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	      74	  15800313 ns/op	  259320 B/op	      18 allocs/op
+BenchmarkPrimeNumbers/input_size_74382-8       	      75	  15783902 ns/op	  259320 B/op	      18 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	       7	 149816095 ns/op	 1160443 B/op	      23 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	       7	 149867261 ns/op	 1160441 B/op	      23 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	       7	 150263752 ns/op	 1160443 B/op	      23 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	       7	 149953671 ns/op	 1160443 B/op	      23 allocs/op
+BenchmarkPrimeNumbers/input_size_382399-8      	       7	 150343783 ns/op	 1160441 B/op	      23 allocs/op
+PASS
+ok  	github.com/CaduceusMetaverseProtocol/metaprotocol/benchmark	26.152s

benchmark/queue-build-tx.go

-package main
+package benchmark
 
 import (
 	"crypto/ecdsa"

benchmark/readme.md

@@ -64,9 +64,9 @@
 
 
 // go  test -v -run EthTx  -bench=.  -benchtime=3s
-// go test   -v -run  BenchmarkQueueAnyTx -bench BenchmarkQueueAnyTx -benchtime=3s  -benchmem
-// go test   -v -run  BenchmarkQueueEthTx -bench BenchmarkQueueEthTx -benchtime=3s  -benchmem
-// go test   -v -run  BenchmarkQueueStdTx -bench BenchmarkQueueStdTx -benchtime=3s  -benchmem
-// go test   -v -run  BenchmarkQueueBytesEth -bench BenchmarkQueueBytesEth -benchtime=3s  -benchmem
+// go test   -v -run  Bench -bench BenchmarkQueueAnyTx -benchtime=3s  -benchmem
+// go test   -v -run  Bench -bench BenchmarkQueueEthTx -benchtime=3s  -benchmem
+// go test   -v -run  Bench -bench BenchmarkQueueStdTx -benchtime=3s  -benchmem
+// go test   -v -run  Bench -bench BenchmarkQueueBytesEth -benchtime=3s  -benchmem
 
 

benchmark/ring_mock.go

+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1 (interfaces: RingServiceClient)
+
+// Package mock_v1 is a generated GoMock package.
+package benchmark
+
+import (
+	context "context"
+	reflect "reflect"
+
+	basev1 "github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/base/v1"
+	ringv1 "github.com/CaduceusMetaverseProtocol/metaprotocol/gen/proto/go/ring/v1"
+	gomock "github.com/golang/mock/gomock"
+	grpc "google.golang.org/grpc"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+// MockRingServiceClient is a mock of RingServiceClient interface.
+type MockRingServiceClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockRingServiceClientMockRecorder
+}
+
+// MockRingServiceClientMockRecorder is the mock recorder for MockRingServiceClient.
+type MockRingServiceClientMockRecorder struct {
+	mock *MockRingServiceClient
+}
+
+// NewMockRingServiceClient creates a new mock instance.
+func NewMockRingServiceClient(ctrl *gomock.Controller) *MockRingServiceClient {
+	mock := &MockRingServiceClient{ctrl: ctrl}
+	mock.recorder = &MockRingServiceClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRingServiceClient) EXPECT() *MockRingServiceClientMockRecorder {
+	return m.recorder
+}
+
+// Nonce mocks base method.
+func (m *MockRingServiceClient) Nonce(arg0 context.Context, arg1 *ringv1.NonceRequest, arg2 ...grpc.CallOption) (*ringv1.NonceResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Nonce", varargs...)
+	ret0, _ := ret[0].(*ringv1.NonceResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Nonce indicates an expected call of Nonce.
+func (mr *MockRingServiceClientMockRecorder) Nonce(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nonce", reflect.TypeOf((*MockRingServiceClient)(nil).Nonce), varargs...)
+}
+
+// SendEmpty mocks base method.
+func (m *MockRingServiceClient) SendEmpty(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*emptypb.Empty, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendEmpty", varargs...)
+	ret0, _ := ret[0].(*emptypb.Empty)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendEmpty indicates an expected call of SendEmpty.
+func (mr *MockRingServiceClientMockRecorder) SendEmpty(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEmpty", reflect.TypeOf((*MockRingServiceClient)(nil).SendEmpty), varargs...)
+}
+
+// SendEmptyMsg mocks base method.
+func (m *MockRingServiceClient) SendEmptyMsg(arg0 context.Context, arg1 *ringv1.EmptyRequest, arg2 ...grpc.CallOption) (*ringv1.EmptyResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendEmptyMsg", varargs...)
+	ret0, _ := ret[0].(*ringv1.EmptyResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendEmptyMsg indicates an expected call of SendEmptyMsg.
+func (mr *MockRingServiceClientMockRecorder) SendEmptyMsg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendEmptyMsg", reflect.TypeOf((*MockRingServiceClient)(nil).SendEmptyMsg), varargs...)
+}
+
+// SendTxAsAny mocks base method.
+func (m *MockRingServiceClient) SendTxAsAny(arg0 context.Context, arg1 *basev1.Transaction, arg2 ...grpc.CallOption) (*ringv1.SendRawTransactionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendTxAsAny", varargs...)
+	ret0, _ := ret[0].(*ringv1.SendRawTransactionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendTxAsAny indicates an expected call of SendTxAsAny.
+func (mr *MockRingServiceClientMockRecorder) SendTxAsAny(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTxAsAny", reflect.TypeOf((*MockRingServiceClient)(nil).SendTxAsAny), varargs...)
+}
+
+// SendTxAsBytes mocks base method.
+func (m *MockRingServiceClient) SendTxAsBytes(arg0 context.Context, arg1 *basev1.TransactionBytes, arg2 ...grpc.CallOption) (*ringv1.SendRawTransactionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendTxAsBytes", varargs...)
+	ret0, _ := ret[0].(*ringv1.SendRawTransactionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendTxAsBytes indicates an expected call of SendTxAsBytes.
+func (mr *MockRingServiceClientMockRecorder) SendTxAsBytes(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTxAsBytes", reflect.TypeOf((*MockRingServiceClient)(nil).SendTxAsBytes), varargs...)
+}
+
+// SendTxAsEth mocks base method.
+func (m *MockRingServiceClient) SendTxAsEth(arg0 context.Context, arg1 *basev1.TransactionEth, arg2 ...grpc.CallOption) (*ringv1.SendRawTransactionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendTxAsEth", varargs...)
+	ret0, _ := ret[0].(*ringv1.SendRawTransactionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendTxAsEth indicates an expected call of SendTxAsEth.
+func (mr *MockRingServiceClientMockRecorder) SendTxAsEth(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTxAsEth", reflect.TypeOf((*MockRingServiceClient)(nil).SendTxAsEth), varargs...)
+}
+
+// SendTxAsStd mocks base method.
+func (m *MockRingServiceClient) SendTxAsStd(arg0 context.Context, arg1 *basev1.TransactionStd, arg2 ...grpc.CallOption) (*ringv1.SendRawTransactionResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SendTxAsStd", varargs...)
+	ret0, _ := ret[0].(*ringv1.SendRawTransactionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SendTxAsStd indicates an expected call of SendTxAsStd.
+func (mr *MockRingServiceClientMockRecorder) SendTxAsStd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendTxAsStd", reflect.TypeOf((*MockRingServiceClient)(nil).SendTxAsStd), varargs...)
+}

benchmark/test_test.go

-package main_test
+package benchmark_test
 
 import (
 	"context"

gen/proto/go/ring/v1/service_grpc.pb.go

@@ -325,3 +325,175 @@ var RingService_ServiceDesc = grpc.ServiceDesc{
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "ring/v1/service.proto",
 }
+
+// MyServiceClient is the client API for MyService service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type MyServiceClient interface {
+	Get(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error)
+}
+
+type myServiceClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewMyServiceClient(cc grpc.ClientConnInterface) MyServiceClient {
+	return &myServiceClient{cc}
+}
+
+func (c *myServiceClient) Get(ctx context.Context, in *Request, opts ...grpc.CallOption) (*Response, error) {
+	out := new(Response)
+	err := c.cc.Invoke(ctx, "/ring.v1.MyService/Get", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// MyServiceServer is the server API for MyService service.
+// All implementations must embed UnimplementedMyServiceServer
+// for forward compatibility
+type MyServiceServer interface {
+	Get(context.Context, *Request) (*Response, error)
+	mustEmbedUnimplementedMyServiceServer()
+}
+
+// UnimplementedMyServiceServer must be embedded to have forward compatible implementations.
+type UnimplementedMyServiceServer struct {
+}
+
+func (UnimplementedMyServiceServer) Get(context.Context, *Request) (*Response, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
+}
+func (UnimplementedMyServiceServer) mustEmbedUnimplementedMyServiceServer() {}
+
+// UnsafeMyServiceServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to MyServiceServer will
+// result in compilation errors.
+type UnsafeMyServiceServer interface {
+	mustEmbedUnimplementedMyServiceServer()
+}
+
+func RegisterMyServiceServer(s grpc.ServiceRegistrar, srv MyServiceServer) {
+	s.RegisterService(&MyService_ServiceDesc, srv)
+}
+
+func _MyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(Request)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MyServiceServer).Get(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ring.v1.MyService/Get",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MyServiceServer).Get(ctx, req.(*Request))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// MyService_ServiceDesc is the grpc.ServiceDesc for MyService service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var MyService_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "ring.v1.MyService",
+	HandlerType: (*MyServiceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Get",
+			Handler:    _MyService_Get_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "ring/v1/service.proto",
+}
+
+// GreeterClient is the client API for Greeter service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+type GreeterClient interface {
+	SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
+}
+
+type greeterClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewGreeterClient(cc grpc.ClientConnInterface) GreeterClient {
+	return &greeterClient{cc}
+}
+
+func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error) {
+	out := new(HelloReply)
+	err := c.cc.Invoke(ctx, "/ring.v1.Greeter/SayHello", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// GreeterServer is the server API for Greeter service.
+// All implementations must embed UnimplementedGreeterServer
+// for forward compatibility
+type GreeterServer interface {
+	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
+	mustEmbedUnimplementedGreeterServer()
+}
+
+// UnimplementedGreeterServer must be embedded to have forward compatible implementations.
+type UnimplementedGreeterServer struct {
+}
+
+func (UnimplementedGreeterServer) SayHello(context.Context, *HelloRequest) (*HelloReply, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method SayHello not implemented")
+}
+func (UnimplementedGreeterServer) mustEmbedUnimplementedGreeterServer() {}
+
+// UnsafeGreeterServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to GreeterServer will
+// result in compilation errors.
+type UnsafeGreeterServer interface {
+	mustEmbedUnimplementedGreeterServer()
+}
+
+func RegisterGreeterServer(s grpc.ServiceRegistrar, srv GreeterServer) {
+	s.RegisterService(&Greeter_ServiceDesc, srv)
+}
+
+func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HelloRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(GreeterServer).SayHello(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/ring.v1.Greeter/SayHello",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Greeter_ServiceDesc is the grpc.ServiceDesc for Greeter service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Greeter_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "ring.v1.Greeter",
+	HandlerType: (*GreeterServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "SayHello",
+			Handler:    _Greeter_SayHello_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "ring/v1/service.proto",
+}

go.mod

@@ -3,22 +3,23 @@ module github.com/CaduceusMetaverseProtocol/metaprotocol
 go 1.18
 
 require (
+	github.com/ethereum/go-ethereum v1.10.26
 	google.golang.org/grpc v1.50.1
 	google.golang.org/protobuf v1.28.1
 )
 
 require (
-	github.com/ethereum/go-ethereum v1.10.26 // indirect
-	github.com/ghodss/yaml v1.0.0 // indirect
-	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
+	github.com/btcsuite/btcd/btcec/v2 v2.2.0 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
+	github.com/golang/mock v1.6.0 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
 	golang.org/x/crypto v0.0.0-20210921155107-089bfa567519 // indirect
-	golang.org/x/net v0.0.0-20220607020251-c690dde0001d // indirect
-	golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a // indirect
-	golang.org/x/text v0.3.7 // indirect
-	google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013 // indirect
-	google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.2.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
+	golang.org/x/net v0.2.0 // indirect
+	golang.org/x/sys v0.2.0 // indirect
+	golang.org/x/text v0.4.0 // indirect
+	golang.org/x/tools v0.1.12 // indirect
+	golang.org/x/xerrors v0.0.0-20220517211312-f3a8303e98df // indirect
+	google.golang.org/genproto v0.0.0-20221118155620-16455021b5e6 // indirect
+	google.golang.org/grpc/examples v0.0.0-20221202020918-001d234e1f2d // indirect
 )

ringapi/ring/v1/service.proto

@@ -33,3 +33,29 @@ message  EmptyRequest {
 }
 message  EmptyResponse {
 }
+
+
+
+service MyService {
+    rpc Get(Request) returns (Response) {}
+  }
+  message Request {}
+  message Response {
+    string id = 1;
+  }
+
+
+
+
+
+message HelloRequest {
+    string name = 1;
+}
+
+message HelloReply {
+    string name = 1;
+}
+
+service Greeter {
+    rpc SayHello (HelloRequest) returns (HelloReply) {}
+}
\ No newline at end of file