spacemeshv2beta1

package
v1.62.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 9, 2025 License: MIT Imports: 20 Imported by: 2

Documentation

Overview

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Package spacemeshv2beta1 is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

View Source 
const (
	ActivationService_List_FullMethodName             = "/spacemesh.v2beta1.ActivationService/List"
	ActivationService_ActivationsCount_FullMethodName = "/spacemesh.v2beta1.ActivationService/ActivationsCount"
	ActivationService_Highest_FullMethodName          = "/spacemesh.v2beta1.ActivationService/Highest"
)
View Source 
const (
	TransactionService_List_FullMethodName              = "/spacemesh.v2beta1.TransactionService/List"
	TransactionService_ParseTransaction_FullMethodName  = "/spacemesh.v2beta1.TransactionService/ParseTransaction"
	TransactionService_SubmitTransaction_FullMethodName = "/spacemesh.v2beta1.TransactionService/SubmitTransaction"
	TransactionService_EstimateGas_FullMethodName       = "/spacemesh.v2beta1.TransactionService/EstimateGas"
)
View Source 
const (
	AccountService_List_FullMethodName = "/spacemesh.v2beta1.AccountService/List"
)
View Source 
const (
	ActivationStreamService_Stream_FullMethodName = "/spacemesh.v2beta1.ActivationStreamService/Stream"
)
View Source 
const (
	LayerService_List_FullMethodName = "/spacemesh.v2beta1.LayerService/List"
)
View Source 
const (
	LayerStreamService_Stream_FullMethodName = "/spacemesh.v2beta1.LayerStreamService/Stream"
)
View Source 
const (
	MalfeasanceService_List_FullMethodName = "/spacemesh.v2beta1.MalfeasanceService/List"
)
View Source 
const (
	MalfeasanceStreamService_Stream_FullMethodName = "/spacemesh.v2beta1.MalfeasanceStreamService/Stream"
)
View Source 
const (
	NetworkService_Info_FullMethodName = "/spacemesh.v2beta1.NetworkService/Info"
)
View Source 
const (
	NodeService_Status_FullMethodName = "/spacemesh.v2beta1.NodeService/Status"
)
View Source 
const (
	RewardService_List_FullMethodName = "/spacemesh.v2beta1.RewardService/List"
)
View Source 
const (
	RewardStreamService_Stream_FullMethodName = "/spacemesh.v2beta1.RewardStreamService/Stream"
)
View Source 
const (
	TransactionStreamService_Stream_FullMethodName = "/spacemesh.v2beta1.TransactionStreamService/Stream"
)

Variables

View Source 
var (
	Layer_LayerStatus_name = map[int32]string{
		0: "LAYER_STATUS_UNSPECIFIED",
		1: "LAYER_STATUS_APPLIED",
		2: "LAYER_STATUS_VERIFIED",
	}
	Layer_LayerStatus_value = map[string]int32{
		"LAYER_STATUS_UNSPECIFIED": 0,
		"LAYER_STATUS_APPLIED":     1,
		"LAYER_STATUS_VERIFIED":    2,
	}
)

Enum value maps for Layer_LayerStatus.

View Source 
var (
	MalfeasanceProof_MalfeasanceDomain_name = map[int32]string{
		0: "DOMAIN_UNSPECIFIED",
		1: "DOMAIN_ACTIVATION",
		2: "DOMAIN_BALLOT",
		3: "DOMAIN_HARE",
	}
	MalfeasanceProof_MalfeasanceDomain_value = map[string]int32{
		"DOMAIN_UNSPECIFIED": 0,
		"DOMAIN_ACTIVATION":  1,
		"DOMAIN_BALLOT":      2,
		"DOMAIN_HARE":        3,
	}
)

Enum value maps for MalfeasanceProof_MalfeasanceDomain.

View Source 
var (
	NodeStatusResponse_SyncStatus_name = map[int32]string{
		0: "SYNC_STATUS_UNSPECIFIED",
		1: "SYNC_STATUS_OFFLINE",
		2: "SYNC_STATUS_SYNCING",
		3: "SYNC_STATUS_SYNCED",
	}
	NodeStatusResponse_SyncStatus_value = map[string]int32{
		"SYNC_STATUS_UNSPECIFIED": 0,
		"SYNC_STATUS_OFFLINE":     1,
		"SYNC_STATUS_SYNCING":     2,
		"SYNC_STATUS_SYNCED":      3,
	}
)

Enum value maps for NodeStatusResponse_SyncStatus.

View Source 
var (
	TransactionState_name = map[int32]string{
		0: "TRANSACTION_STATE_UNSPECIFIED",
		1: "TRANSACTION_STATE_REJECTED",
		2: "TRANSACTION_STATE_INSUFFICIENT_FUNDS",
		3: "TRANSACTION_STATE_CONFLICTING",
		4: "TRANSACTION_STATE_MEMPOOL",
		5: "TRANSACTION_STATE_MESH",
		6: "TRANSACTION_STATE_PROCESSED",
		7: "TRANSACTION_STATE_INEFFECTUAL",
	}
	TransactionState_value = map[string]int32{
		"TRANSACTION_STATE_UNSPECIFIED":        0,
		"TRANSACTION_STATE_REJECTED":           1,
		"TRANSACTION_STATE_INSUFFICIENT_FUNDS": 2,
		"TRANSACTION_STATE_CONFLICTING":        3,
		"TRANSACTION_STATE_MEMPOOL":            4,
		"TRANSACTION_STATE_MESH":               5,
		"TRANSACTION_STATE_PROCESSED":          6,
		"TRANSACTION_STATE_INEFFECTUAL":        7,
	}
)

Enum value maps for TransactionState.

View Source 
var (
	Transaction_TransactionType_name = map[int32]string{
		0: "TRANSACTION_TYPE_UNSPECIFIED",
		1: "TRANSACTION_TYPE_SINGLE_SIG_SEND",
		2: "TRANSACTION_TYPE_SINGLE_SIG_SPAWN",
		3: "TRANSACTION_TYPE_SINGLE_SIG_SELFSPAWN",
		4: "TRANSACTION_TYPE_MULTI_SIG_SEND",
		5: "TRANSACTION_TYPE_MULTI_SIG_SPAWN",
		6: "TRANSACTION_TYPE_MULTI_SIG_SELFSPAWN",
		7: "TRANSACTION_TYPE_VESTING_SPAWN",
		8: "TRANSACTION_TYPE_VAULT_SPAWN",
		9: "TRANSACTION_TYPE_DRAIN_VAULT",
	}
	Transaction_TransactionType_value = map[string]int32{
		"TRANSACTION_TYPE_UNSPECIFIED":          0,
		"TRANSACTION_TYPE_SINGLE_SIG_SEND":      1,
		"TRANSACTION_TYPE_SINGLE_SIG_SPAWN":     2,
		"TRANSACTION_TYPE_SINGLE_SIG_SELFSPAWN": 3,
		"TRANSACTION_TYPE_MULTI_SIG_SEND":       4,
		"TRANSACTION_TYPE_MULTI_SIG_SPAWN":      5,
		"TRANSACTION_TYPE_MULTI_SIG_SELFSPAWN":  6,
		"TRANSACTION_TYPE_VESTING_SPAWN":        7,
		"TRANSACTION_TYPE_VAULT_SPAWN":          8,
		"TRANSACTION_TYPE_DRAIN_VAULT":          9,
	}
)

Enum value maps for Transaction_TransactionType.

View Source 
var (
	TransactionResult_Status_name = map[int32]string{
		0: "TRANSACTION_STATUS_UNSPECIFIED",
		1: "TRANSACTION_STATUS_SUCCESS",
		2: "TRANSACTION_STATUS_FAILURE",
		3: "TRANSACTION_STATUS_INVALID",
	}
	TransactionResult_Status_value = map[string]int32{
		"TRANSACTION_STATUS_UNSPECIFIED": 0,
		"TRANSACTION_STATUS_SUCCESS":     1,
		"TRANSACTION_STATUS_FAILURE":     2,
		"TRANSACTION_STATUS_INVALID":     3,
	}
)

Enum value maps for TransactionResult_Status.

View Source 
var (
	SortOrder_name = map[int32]string{
		0: "ASC",
		1: "DESC",
	}
	SortOrder_value = map[string]int32{
		"ASC":  0,
		"DESC": 1,
	}
)

Enum value maps for SortOrder.

View Source 
var AccountService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.AccountService",
	HandlerType: (*AccountServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _AccountService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/account.proto",
}

AccountService_ServiceDesc is the grpc.ServiceDesc for AccountService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ActivationService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.ActivationService",
	HandlerType: (*ActivationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _ActivationService_List_Handler,
		},
		{
			MethodName: "ActivationsCount",
			Handler:    _ActivationService_ActivationsCount_Handler,
		},
		{
			MethodName: "Highest",
			Handler:    _ActivationService_Highest_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/activation.proto",
}

ActivationService_ServiceDesc is the grpc.ServiceDesc for ActivationService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var ActivationStreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.ActivationStreamService",
	HandlerType: (*ActivationStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _ActivationStreamService_Stream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "spacemesh/v2beta1/activation.proto",
}

ActivationStreamService_ServiceDesc is the grpc.ServiceDesc for ActivationStreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var File_spacemesh_v2beta1_account_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_activation_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_block_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_layer_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_malfeasance_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_network_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_node_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_reward_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_tx_proto protoreflect.FileDescriptor
View Source 
var File_spacemesh_v2beta1_v2beta1_proto protoreflect.FileDescriptor
View Source 
var LayerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.LayerService",
	HandlerType: (*LayerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _LayerService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/layer.proto",
}

LayerService_ServiceDesc is the grpc.ServiceDesc for LayerService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var LayerStreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.LayerStreamService",
	HandlerType: (*LayerStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _LayerStreamService_Stream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "spacemesh/v2beta1/layer.proto",
}

LayerStreamService_ServiceDesc is the grpc.ServiceDesc for LayerStreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var MalfeasanceService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.MalfeasanceService",
	HandlerType: (*MalfeasanceServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _MalfeasanceService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/malfeasance.proto",
}

MalfeasanceService_ServiceDesc is the grpc.ServiceDesc for MalfeasanceService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var MalfeasanceStreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.MalfeasanceStreamService",
	HandlerType: (*MalfeasanceStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _MalfeasanceStreamService_Stream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "spacemesh/v2beta1/malfeasance.proto",
}

MalfeasanceStreamService_ServiceDesc is the grpc.ServiceDesc for MalfeasanceStreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var NetworkService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.NetworkService",
	HandlerType: (*NetworkServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Info",
			Handler:    _NetworkService_Info_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/network.proto",
}

NetworkService_ServiceDesc is the grpc.ServiceDesc for NetworkService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var NodeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.NodeService",
	HandlerType: (*NodeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Status",
			Handler:    _NodeService_Status_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/node.proto",
}

NodeService_ServiceDesc is the grpc.ServiceDesc for NodeService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var RewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.RewardService",
	HandlerType: (*RewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _RewardService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/reward.proto",
}

RewardService_ServiceDesc is the grpc.ServiceDesc for RewardService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var RewardStreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.RewardStreamService",
	HandlerType: (*RewardStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _RewardStreamService_Stream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "spacemesh/v2beta1/reward.proto",
}

RewardStreamService_ServiceDesc is the grpc.ServiceDesc for RewardStreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var TransactionService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.TransactionService",
	HandlerType: (*TransactionServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _TransactionService_List_Handler,
		},
		{
			MethodName: "ParseTransaction",
			Handler:    _TransactionService_ParseTransaction_Handler,
		},
		{
			MethodName: "SubmitTransaction",
			Handler:    _TransactionService_SubmitTransaction_Handler,
		},
		{
			MethodName: "EstimateGas",
			Handler:    _TransactionService_EstimateGas_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "spacemesh/v2beta1/tx.proto",
}

TransactionService_ServiceDesc is the grpc.ServiceDesc for TransactionService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

View Source 
var TransactionStreamService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "spacemesh.v2beta1.TransactionStreamService",
	HandlerType: (*TransactionStreamServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Stream",
			Handler:       _TransactionStreamService_Stream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "spacemesh/v2beta1/tx.proto",
}

TransactionStreamService_ServiceDesc is the grpc.ServiceDesc for TransactionStreamService service. It's only intended for direct use with grpc.RegisterService, and not to be introspected or modified (even as a copy)

Functions

func RegisterAccountServiceHandler 

func RegisterAccountServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterAccountServiceHandler registers the http handlers for service AccountService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterAccountServiceHandlerClient 

func RegisterAccountServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client AccountServiceClient) error

RegisterAccountServiceHandlerClient registers the http handlers for service AccountService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "AccountServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "AccountServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "AccountServiceClient" to call the correct interceptors.

func RegisterAccountServiceHandlerFromEndpoint 

func RegisterAccountServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterAccountServiceHandlerFromEndpoint is same as RegisterAccountServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterAccountServiceHandlerServer 

func RegisterAccountServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server AccountServiceServer) error

RegisterAccountServiceHandlerServer registers the http handlers for service AccountService to "mux". UnaryRPC :call AccountServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterAccountServiceHandlerFromEndpoint instead.

func RegisterAccountServiceServer 

func RegisterAccountServiceServer(s grpc.ServiceRegistrar, srv AccountServiceServer)

func RegisterActivationServiceHandler 

func RegisterActivationServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterActivationServiceHandler registers the http handlers for service ActivationService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterActivationServiceHandlerClient 

func RegisterActivationServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ActivationServiceClient) error

RegisterActivationServiceHandlerClient registers the http handlers for service ActivationService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ActivationServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ActivationServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ActivationServiceClient" to call the correct interceptors.

func RegisterActivationServiceHandlerFromEndpoint 

func RegisterActivationServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterActivationServiceHandlerFromEndpoint is same as RegisterActivationServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterActivationServiceHandlerServer 

func RegisterActivationServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ActivationServiceServer) error

RegisterActivationServiceHandlerServer registers the http handlers for service ActivationService to "mux". UnaryRPC :call ActivationServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterActivationServiceHandlerFromEndpoint instead.

func RegisterActivationServiceServer 

func RegisterActivationServiceServer(s grpc.ServiceRegistrar, srv ActivationServiceServer)

func RegisterActivationStreamServiceHandler 

func RegisterActivationStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterActivationStreamServiceHandler registers the http handlers for service ActivationStreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterActivationStreamServiceHandlerClient 

func RegisterActivationStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ActivationStreamServiceClient) error

RegisterActivationStreamServiceHandlerClient registers the http handlers for service ActivationStreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ActivationStreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ActivationStreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "ActivationStreamServiceClient" to call the correct interceptors.

func RegisterActivationStreamServiceHandlerFromEndpoint 

func RegisterActivationStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterActivationStreamServiceHandlerFromEndpoint is same as RegisterActivationStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterActivationStreamServiceHandlerServer 

func RegisterActivationStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ActivationStreamServiceServer) error

RegisterActivationStreamServiceHandlerServer registers the http handlers for service ActivationStreamService to "mux". UnaryRPC :call ActivationStreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterActivationStreamServiceHandlerFromEndpoint instead.

func RegisterActivationStreamServiceServer 

func RegisterActivationStreamServiceServer(s grpc.ServiceRegistrar, srv ActivationStreamServiceServer)

func RegisterLayerServiceHandler 

func RegisterLayerServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLayerServiceHandler registers the http handlers for service LayerService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLayerServiceHandlerClient 

func RegisterLayerServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LayerServiceClient) error

RegisterLayerServiceHandlerClient registers the http handlers for service LayerService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LayerServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LayerServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LayerServiceClient" to call the correct interceptors.

func RegisterLayerServiceHandlerFromEndpoint 

func RegisterLayerServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLayerServiceHandlerFromEndpoint is same as RegisterLayerServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLayerServiceHandlerServer 

func RegisterLayerServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LayerServiceServer) error

RegisterLayerServiceHandlerServer registers the http handlers for service LayerService to "mux". UnaryRPC :call LayerServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterLayerServiceHandlerFromEndpoint instead.

func RegisterLayerServiceServer 

func RegisterLayerServiceServer(s grpc.ServiceRegistrar, srv LayerServiceServer)

func RegisterLayerStreamServiceHandler 

func RegisterLayerStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterLayerStreamServiceHandler registers the http handlers for service LayerStreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterLayerStreamServiceHandlerClient 

func RegisterLayerStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client LayerStreamServiceClient) error

RegisterLayerStreamServiceHandlerClient registers the http handlers for service LayerStreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "LayerStreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "LayerStreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "LayerStreamServiceClient" to call the correct interceptors.

func RegisterLayerStreamServiceHandlerFromEndpoint 

func RegisterLayerStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterLayerStreamServiceHandlerFromEndpoint is same as RegisterLayerStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterLayerStreamServiceHandlerServer 

func RegisterLayerStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server LayerStreamServiceServer) error

RegisterLayerStreamServiceHandlerServer registers the http handlers for service LayerStreamService to "mux". UnaryRPC :call LayerStreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterLayerStreamServiceHandlerFromEndpoint instead.

func RegisterLayerStreamServiceServer 

func RegisterLayerStreamServiceServer(s grpc.ServiceRegistrar, srv LayerStreamServiceServer)

func RegisterMalfeasanceServiceHandler 

func RegisterMalfeasanceServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMalfeasanceServiceHandler registers the http handlers for service MalfeasanceService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMalfeasanceServiceHandlerClient 

func RegisterMalfeasanceServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MalfeasanceServiceClient) error

RegisterMalfeasanceServiceHandlerClient registers the http handlers for service MalfeasanceService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MalfeasanceServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MalfeasanceServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MalfeasanceServiceClient" to call the correct interceptors.

func RegisterMalfeasanceServiceHandlerFromEndpoint 

func RegisterMalfeasanceServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMalfeasanceServiceHandlerFromEndpoint is same as RegisterMalfeasanceServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMalfeasanceServiceHandlerServer 

func RegisterMalfeasanceServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MalfeasanceServiceServer) error

RegisterMalfeasanceServiceHandlerServer registers the http handlers for service MalfeasanceService to "mux". UnaryRPC :call MalfeasanceServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMalfeasanceServiceHandlerFromEndpoint instead.

func RegisterMalfeasanceServiceServer 

func RegisterMalfeasanceServiceServer(s grpc.ServiceRegistrar, srv MalfeasanceServiceServer)

func RegisterMalfeasanceStreamServiceHandler 

func RegisterMalfeasanceStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterMalfeasanceStreamServiceHandler registers the http handlers for service MalfeasanceStreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterMalfeasanceStreamServiceHandlerClient 

func RegisterMalfeasanceStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client MalfeasanceStreamServiceClient) error

RegisterMalfeasanceStreamServiceHandlerClient registers the http handlers for service MalfeasanceStreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "MalfeasanceStreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "MalfeasanceStreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "MalfeasanceStreamServiceClient" to call the correct interceptors.

func RegisterMalfeasanceStreamServiceHandlerFromEndpoint 

func RegisterMalfeasanceStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterMalfeasanceStreamServiceHandlerFromEndpoint is same as RegisterMalfeasanceStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterMalfeasanceStreamServiceHandlerServer 

func RegisterMalfeasanceStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server MalfeasanceStreamServiceServer) error

RegisterMalfeasanceStreamServiceHandlerServer registers the http handlers for service MalfeasanceStreamService to "mux". UnaryRPC :call MalfeasanceStreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterMalfeasanceStreamServiceHandlerFromEndpoint instead.

func RegisterMalfeasanceStreamServiceServer 

func RegisterMalfeasanceStreamServiceServer(s grpc.ServiceRegistrar, srv MalfeasanceStreamServiceServer)

func RegisterNetworkServiceHandler 

func RegisterNetworkServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNetworkServiceHandler registers the http handlers for service NetworkService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNetworkServiceHandlerClient 

func RegisterNetworkServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NetworkServiceClient) error

RegisterNetworkServiceHandlerClient registers the http handlers for service NetworkService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NetworkServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NetworkServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NetworkServiceClient" to call the correct interceptors.

func RegisterNetworkServiceHandlerFromEndpoint 

func RegisterNetworkServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNetworkServiceHandlerFromEndpoint is same as RegisterNetworkServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNetworkServiceHandlerServer 

func RegisterNetworkServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NetworkServiceServer) error

RegisterNetworkServiceHandlerServer registers the http handlers for service NetworkService to "mux". UnaryRPC :call NetworkServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNetworkServiceHandlerFromEndpoint instead.

func RegisterNetworkServiceServer 

func RegisterNetworkServiceServer(s grpc.ServiceRegistrar, srv NetworkServiceServer)

func RegisterNodeServiceHandler 

func RegisterNodeServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterNodeServiceHandler registers the http handlers for service NodeService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterNodeServiceHandlerClient 

func RegisterNodeServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client NodeServiceClient) error

RegisterNodeServiceHandlerClient registers the http handlers for service NodeService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "NodeServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "NodeServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "NodeServiceClient" to call the correct interceptors.

func RegisterNodeServiceHandlerFromEndpoint 

func RegisterNodeServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterNodeServiceHandlerFromEndpoint is same as RegisterNodeServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterNodeServiceHandlerServer 

func RegisterNodeServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server NodeServiceServer) error

RegisterNodeServiceHandlerServer registers the http handlers for service NodeService to "mux". UnaryRPC :call NodeServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterNodeServiceHandlerFromEndpoint instead.

func RegisterNodeServiceServer 

func RegisterNodeServiceServer(s grpc.ServiceRegistrar, srv NodeServiceServer)

func RegisterRewardServiceHandler 

func RegisterRewardServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterRewardServiceHandler registers the http handlers for service RewardService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterRewardServiceHandlerClient 

func RegisterRewardServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client RewardServiceClient) error

RegisterRewardServiceHandlerClient registers the http handlers for service RewardService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "RewardServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "RewardServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "RewardServiceClient" to call the correct interceptors.

func RegisterRewardServiceHandlerFromEndpoint 

func RegisterRewardServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterRewardServiceHandlerFromEndpoint is same as RegisterRewardServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterRewardServiceHandlerServer 

func RegisterRewardServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server RewardServiceServer) error

RegisterRewardServiceHandlerServer registers the http handlers for service RewardService to "mux". UnaryRPC :call RewardServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterRewardServiceHandlerFromEndpoint instead.

func RegisterRewardServiceServer 

func RegisterRewardServiceServer(s grpc.ServiceRegistrar, srv RewardServiceServer)

func RegisterRewardStreamServiceHandler 

func RegisterRewardStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterRewardStreamServiceHandler registers the http handlers for service RewardStreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterRewardStreamServiceHandlerClient 

func RegisterRewardStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client RewardStreamServiceClient) error

RegisterRewardStreamServiceHandlerClient registers the http handlers for service RewardStreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "RewardStreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "RewardStreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "RewardStreamServiceClient" to call the correct interceptors.

func RegisterRewardStreamServiceHandlerFromEndpoint 

func RegisterRewardStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterRewardStreamServiceHandlerFromEndpoint is same as RegisterRewardStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterRewardStreamServiceHandlerServer 

func RegisterRewardStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server RewardStreamServiceServer) error

RegisterRewardStreamServiceHandlerServer registers the http handlers for service RewardStreamService to "mux". UnaryRPC :call RewardStreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterRewardStreamServiceHandlerFromEndpoint instead.

func RegisterRewardStreamServiceServer 

func RegisterRewardStreamServiceServer(s grpc.ServiceRegistrar, srv RewardStreamServiceServer)

func RegisterTransactionServiceHandler 

func RegisterTransactionServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterTransactionServiceHandler registers the http handlers for service TransactionService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterTransactionServiceHandlerClient 

func RegisterTransactionServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TransactionServiceClient) error

RegisterTransactionServiceHandlerClient registers the http handlers for service TransactionService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TransactionServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TransactionServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "TransactionServiceClient" to call the correct interceptors.

func RegisterTransactionServiceHandlerFromEndpoint 

func RegisterTransactionServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterTransactionServiceHandlerFromEndpoint is same as RegisterTransactionServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterTransactionServiceHandlerServer 

func RegisterTransactionServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server TransactionServiceServer) error

RegisterTransactionServiceHandlerServer registers the http handlers for service TransactionService to "mux". UnaryRPC :call TransactionServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterTransactionServiceHandlerFromEndpoint instead.

func RegisterTransactionServiceServer 

func RegisterTransactionServiceServer(s grpc.ServiceRegistrar, srv TransactionServiceServer)

func RegisterTransactionStreamServiceHandler 

func RegisterTransactionStreamServiceHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterTransactionStreamServiceHandler registers the http handlers for service TransactionStreamService to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterTransactionStreamServiceHandlerClient 

func RegisterTransactionStreamServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TransactionStreamServiceClient) error

RegisterTransactionStreamServiceHandlerClient registers the http handlers for service TransactionStreamService to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "TransactionStreamServiceClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "TransactionStreamServiceClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "TransactionStreamServiceClient" to call the correct interceptors.

func RegisterTransactionStreamServiceHandlerFromEndpoint 

func RegisterTransactionStreamServiceHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterTransactionStreamServiceHandlerFromEndpoint is same as RegisterTransactionStreamServiceHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterTransactionStreamServiceHandlerServer 

func RegisterTransactionStreamServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux, server TransactionStreamServiceServer) error

RegisterTransactionStreamServiceHandlerServer registers the http handlers for service TransactionStreamService to "mux". UnaryRPC :call TransactionStreamServiceServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterTransactionStreamServiceHandlerFromEndpoint instead.

func RegisterTransactionStreamServiceServer 

func RegisterTransactionStreamServiceServer(s grpc.ServiceRegistrar, srv TransactionStreamServiceServer)

Types

type Account 

type Account struct {
	Address   string        `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`     // account public address
	Current   *AccountState `protobuf:"bytes,2,opt,name=current,proto3" json:"current,omitempty"`     // current state
	Projected *AccountState `protobuf:"bytes,3,opt,name=projected,proto3" json:"projected,omitempty"` // projected state (includes pending txs)
	Template  string        `protobuf:"bytes,4,opt,name=template,proto3" json:"template,omitempty"`   // account template address
	// contains filtered or unexported fields
}

func (*Account) Descriptor deprecated 

func (*Account) Descriptor() ([]byte, []int)

Deprecated: Use Account.ProtoReflect.Descriptor instead.

func (*Account) GetAddress 

func (x *Account) GetAddress() string

func (*Account) GetCurrent 

func (x *Account) GetCurrent() *AccountState

func (*Account) GetProjected 

func (x *Account) GetProjected() *AccountState

func (*Account) GetTemplate 

func (x *Account) GetTemplate() string

func (*Account) ProtoMessage 

func (*Account) ProtoMessage()

func (*Account) ProtoReflect 

func (x *Account) ProtoReflect() protoreflect.Message

func (*Account) Reset 

func (x *Account) Reset()

func (*Account) String 

func (x *Account) String() string

type AccountList 

type AccountList struct {
	Accounts []*Account `protobuf:"bytes,1,rep,name=accounts,proto3" json:"accounts,omitempty"` // list of accounts
	// contains filtered or unexported fields
}

func (*AccountList) Descriptor deprecated 

func (*AccountList) Descriptor() ([]byte, []int)

Deprecated: Use AccountList.ProtoReflect.Descriptor instead.

func (*AccountList) GetAccounts 

func (x *AccountList) GetAccounts() []*Account

func (*AccountList) ProtoMessage 

func (*AccountList) ProtoMessage()

func (*AccountList) ProtoReflect 

func (x *AccountList) ProtoReflect() protoreflect.Message

func (*AccountList) Reset 

func (x *AccountList) Reset()

func (*AccountList) String 

func (x *AccountList) String() string

type AccountRequest 

type AccountRequest struct {
	Addresses []string `protobuf:"bytes,1,rep,name=addresses,proto3" json:"addresses,omitempty"` // list of account addresses
	Offset    uint64   `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`      // adjusts the starting point for data
	Limit     uint64   `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`        // specifies max number of items to fetch// bech32 format including HRP
	// contains filtered or unexported fields
}

func (*AccountRequest) Descriptor deprecated 

func (*AccountRequest) Descriptor() ([]byte, []int)

Deprecated: Use AccountRequest.ProtoReflect.Descriptor instead.

func (*AccountRequest) GetAddresses 

func (x *AccountRequest) GetAddresses() []string

func (*AccountRequest) GetLimit 

func (x *AccountRequest) GetLimit() uint64

func (*AccountRequest) GetOffset 

func (x *AccountRequest) GetOffset() uint64

func (*AccountRequest) ProtoMessage 

func (*AccountRequest) ProtoMessage()

func (*AccountRequest) ProtoReflect 

func (x *AccountRequest) ProtoReflect() protoreflect.Message

func (*AccountRequest) Reset 

func (x *AccountRequest) Reset()

func (*AccountRequest) String 

func (x *AccountRequest) String() string

type AccountServiceClient 

type AccountServiceClient interface {
	// List of accounts
	//
	// List is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of accounts based on the provided request parameters.
	List(ctx context.Context, in *AccountRequest, opts ...grpc.CallOption) (*AccountList, error)
}

AccountServiceClient is the client API for AccountService 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.

func NewAccountServiceClient 

func NewAccountServiceClient(cc grpc.ClientConnInterface) AccountServiceClient

type AccountServiceServer 

type AccountServiceServer interface {
	// List of accounts
	//
	// List is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of accounts based on the provided request parameters.
	List(context.Context, *AccountRequest) (*AccountList, error)
}

AccountServiceServer is the server API for AccountService service. All implementations should embed UnimplementedAccountServiceServer for forward compatibility

type AccountState 

type AccountState struct {
	Counter uint64 `protobuf:"varint,1,opt,name=counter,proto3" json:"counter,omitempty"` // aka nonce
	Balance uint64 `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty"` // account balance in smidge
	Layer   uint32 `protobuf:"varint,3,opt,name=layer,proto3" json:"layer,omitempty"`     // account balance as of layer X
	// contains filtered or unexported fields
}

func (*AccountState) Descriptor deprecated 

func (*AccountState) Descriptor() ([]byte, []int)

Deprecated: Use AccountState.ProtoReflect.Descriptor instead.

func (*AccountState) GetBalance 

func (x *AccountState) GetBalance() uint64

func (*AccountState) GetCounter 

func (x *AccountState) GetCounter() uint64

func (*AccountState) GetLayer 

func (x *AccountState) GetLayer() uint32

func (*AccountState) ProtoMessage 

func (*AccountState) ProtoMessage()

func (*AccountState) ProtoReflect 

func (x *AccountState) ProtoReflect() protoreflect.Message

func (*AccountState) Reset 

func (x *AccountState) Reset()

func (*AccountState) String 

func (x *AccountState) String() string

type Activation 

type Activation struct {
	Id           []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	SmesherId    []byte `protobuf:"bytes,2,opt,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"`
	PublishEpoch uint32 `protobuf:"varint,3,opt,name=publish_epoch,json=publishEpoch,proto3" json:"publish_epoch,omitempty"`
	Coinbase     string `protobuf:"bytes,4,opt,name=coinbase,proto3" json:"coinbase,omitempty"`
	Weight       uint64 `protobuf:"varint,5,opt,name=weight,proto3" json:"weight,omitempty"`
	Height       uint64 `protobuf:"varint,6,opt,name=height,proto3" json:"height,omitempty"`
	NumUnits     uint32 `protobuf:"varint,7,opt,name=num_units,json=numUnits,proto3" json:"num_units,omitempty"` // number of effective PoST data commitment units
	// contains filtered or unexported fields
}

func (*Activation) Descriptor deprecated 

func (*Activation) Descriptor() ([]byte, []int)

Deprecated: Use Activation.ProtoReflect.Descriptor instead.

func (*Activation) GetCoinbase 

func (x *Activation) GetCoinbase() string

func (*Activation) GetHeight 

func (x *Activation) GetHeight() uint64

func (*Activation) GetId 

func (x *Activation) GetId() []byte

func (*Activation) GetNumUnits 

func (x *Activation) GetNumUnits() uint32

func (*Activation) GetPublishEpoch 

func (x *Activation) GetPublishEpoch() uint32

func (*Activation) GetSmesherId 

func (x *Activation) GetSmesherId() []byte

func (*Activation) GetWeight 

func (x *Activation) GetWeight() uint64

func (*Activation) ProtoMessage 

func (*Activation) ProtoMessage()

func (*Activation) ProtoReflect 

func (x *Activation) ProtoReflect() protoreflect.Message

func (*Activation) Reset 

func (x *Activation) Reset()

func (*Activation) String 

func (x *Activation) String() string

type ActivationList 

type ActivationList struct {
	Activations []*Activation `protobuf:"bytes,1,rep,name=activations,proto3" json:"activations,omitempty"` // list of activations
	// contains filtered or unexported fields
}

func (*ActivationList) Descriptor deprecated 

func (*ActivationList) Descriptor() ([]byte, []int)

Deprecated: Use ActivationList.ProtoReflect.Descriptor instead.

func (*ActivationList) GetActivations 

func (x *ActivationList) GetActivations() []*Activation

func (*ActivationList) ProtoMessage 

func (*ActivationList) ProtoMessage()

func (*ActivationList) ProtoReflect 

func (x *ActivationList) ProtoReflect() protoreflect.Message

func (*ActivationList) Reset 

func (x *ActivationList) Reset()

func (*ActivationList) String 

func (x *ActivationList) String() string

type ActivationRequest 

type ActivationRequest struct {
	StartEpoch uint32   `protobuf:"varint,1,opt,name=start_epoch,json=startEpoch,proto3" json:"start_epoch,omitempty"` // starting epoch for the query
	EndEpoch   uint32   `protobuf:"varint,2,opt,name=end_epoch,json=endEpoch,proto3" json:"end_epoch,omitempty"`       // ending epoch for the query
	Id         [][]byte `protobuf:"bytes,3,rep,name=id,proto3" json:"id,omitempty"`                                    // list of activation IDs
	SmesherId  [][]byte `protobuf:"bytes,4,rep,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"`     // list of smesher IDs
	Coinbase   string   `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"`                        // `coinbase` filter is not supported by database index and will result in sequential scan.
	Offset     uint64   `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`                           // adjusts the starting point for data
	Limit      uint64   `protobuf:"varint,7,opt,name=limit,proto3" json:"limit,omitempty"`                             // specifies max number of items to fetch
	// contains filtered or unexported fields
}

func (*ActivationRequest) Descriptor deprecated 

func (*ActivationRequest) Descriptor() ([]byte, []int)

Deprecated: Use ActivationRequest.ProtoReflect.Descriptor instead.

func (*ActivationRequest) GetCoinbase 

func (x *ActivationRequest) GetCoinbase() string

func (*ActivationRequest) GetEndEpoch 

func (x *ActivationRequest) GetEndEpoch() uint32

func (*ActivationRequest) GetId 

func (x *ActivationRequest) GetId() [][]byte

func (*ActivationRequest) GetLimit 

func (x *ActivationRequest) GetLimit() uint64

func (*ActivationRequest) GetOffset 

func (x *ActivationRequest) GetOffset() uint64

func (*ActivationRequest) GetSmesherId 

func (x *ActivationRequest) GetSmesherId() [][]byte

func (*ActivationRequest) GetStartEpoch 

func (x *ActivationRequest) GetStartEpoch() uint32

func (*ActivationRequest) ProtoMessage 

func (*ActivationRequest) ProtoMessage()

func (*ActivationRequest) ProtoReflect 

func (x *ActivationRequest) ProtoReflect() protoreflect.Message

func (*ActivationRequest) Reset 

func (x *ActivationRequest) Reset()

func (*ActivationRequest) String 

func (x *ActivationRequest) String() string

type ActivationServiceClient 

type ActivationServiceClient interface {
	// List of activations
	//
	// List is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of activations based on the provided request parameters.
	List(ctx context.Context, in *ActivationRequest, opts ...grpc.CallOption) (*ActivationList, error)
	// Count of activations
	//
	// ActivationsCount is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve the count of activations for a specified epoch.
	ActivationsCount(ctx context.Context, in *ActivationsCountRequest, opts ...grpc.CallOption) (*ActivationsCountResponse, error)
	// Highest
	//
	// Highest is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve the activation with the highest tick count.
	Highest(ctx context.Context, in *HighestRequest, opts ...grpc.CallOption) (*HighestResponse, error)
}

ActivationServiceClient is the client API for ActivationService 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.

func NewActivationServiceClient 

func NewActivationServiceClient(cc grpc.ClientConnInterface) ActivationServiceClient

type ActivationServiceServer 

type ActivationServiceServer interface {
	// List of activations
	//
	// List is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of activations based on the provided request parameters.
	List(context.Context, *ActivationRequest) (*ActivationList, error)
	// Count of activations
	//
	// ActivationsCount is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve the count of activations for a specified epoch.
	ActivationsCount(context.Context, *ActivationsCountRequest) (*ActivationsCountResponse, error)
	// Highest
	//
	// Highest is a method that takes an "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve the activation with the highest tick count.
	Highest(context.Context, *HighestRequest) (*HighestResponse, error)
}

ActivationServiceServer is the server API for ActivationService service. All implementations should embed UnimplementedActivationServiceServer for forward compatibility

type ActivationStreamRequest 

type ActivationStreamRequest struct {
	StartEpoch uint32   `protobuf:"varint,1,opt,name=start_epoch,json=startEpoch,proto3" json:"start_epoch,omitempty"` // Apply `start_epoch/end_epoch` filters together with `coinbase` filter for better performance.
	EndEpoch   uint32   `protobuf:"varint,2,opt,name=end_epoch,json=endEpoch,proto3" json:"end_epoch,omitempty"`
	Id         [][]byte `protobuf:"bytes,3,rep,name=id,proto3" json:"id,omitempty"`
	SmesherId  [][]byte `protobuf:"bytes,4,rep,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"`
	Coinbase   string   `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"` // `coinbase` filter is not supported by database index and will result in sequential scan.
	Watch      bool     `protobuf:"varint,6,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

func (*ActivationStreamRequest) Descriptor deprecated 

func (*ActivationStreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use ActivationStreamRequest.ProtoReflect.Descriptor instead.

func (*ActivationStreamRequest) GetCoinbase 

func (x *ActivationStreamRequest) GetCoinbase() string

func (*ActivationStreamRequest) GetEndEpoch 

func (x *ActivationStreamRequest) GetEndEpoch() uint32

func (*ActivationStreamRequest) GetId 

func (x *ActivationStreamRequest) GetId() [][]byte

func (*ActivationStreamRequest) GetSmesherId 

func (x *ActivationStreamRequest) GetSmesherId() [][]byte

func (*ActivationStreamRequest) GetStartEpoch 

func (x *ActivationStreamRequest) GetStartEpoch() uint32

func (*ActivationStreamRequest) GetWatch 

func (x *ActivationStreamRequest) GetWatch() bool

func (*ActivationStreamRequest) ProtoMessage 

func (*ActivationStreamRequest) ProtoMessage()

func (*ActivationStreamRequest) ProtoReflect 

func (x *ActivationStreamRequest) ProtoReflect() protoreflect.Message

func (*ActivationStreamRequest) Reset 

func (x *ActivationStreamRequest) Reset()

func (*ActivationStreamRequest) String 

func (x *ActivationStreamRequest) String() string

type ActivationStreamServiceClient 

type ActivationStreamServiceClient interface {
	Stream(ctx context.Context, in *ActivationStreamRequest, opts ...grpc.CallOption) (ActivationStreamService_StreamClient, error)
}

ActivationStreamServiceClient is the client API for ActivationStreamService 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.

func NewActivationStreamServiceClient 

func NewActivationStreamServiceClient(cc grpc.ClientConnInterface) ActivationStreamServiceClient

type ActivationStreamServiceServer 

type ActivationStreamServiceServer interface {
	Stream(*ActivationStreamRequest, ActivationStreamService_StreamServer) error
}

ActivationStreamServiceServer is the server API for ActivationStreamService service. All implementations should embed UnimplementedActivationStreamServiceServer for forward compatibility

type ActivationStreamService_StreamClient 

type ActivationStreamService_StreamClient interface {
	Recv() (*Activation, error)
	grpc.ClientStream
}

type ActivationStreamService_StreamServer 

type ActivationStreamService_StreamServer interface {
	Send(*Activation) error
	grpc.ServerStream
}

type ActivationsCountRequest 

type ActivationsCountRequest struct {
	Epoch *uint32 `protobuf:"varint,1,opt,name=epoch,proto3,oneof" json:"epoch,omitempty"` // epoch number
	// contains filtered or unexported fields
}

func (*ActivationsCountRequest) Descriptor deprecated 

func (*ActivationsCountRequest) Descriptor() ([]byte, []int)

Deprecated: Use ActivationsCountRequest.ProtoReflect.Descriptor instead.

func (*ActivationsCountRequest) GetEpoch 

func (x *ActivationsCountRequest) GetEpoch() uint32

func (*ActivationsCountRequest) ProtoMessage 

func (*ActivationsCountRequest) ProtoMessage()

func (*ActivationsCountRequest) ProtoReflect 

func (x *ActivationsCountRequest) ProtoReflect() protoreflect.Message

func (*ActivationsCountRequest) Reset 

func (x *ActivationsCountRequest) Reset()

func (*ActivationsCountRequest) String 

func (x *ActivationsCountRequest) String() string

type ActivationsCountResponse 

type ActivationsCountResponse struct {
	Count uint32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` // number of activations for the specified epoch
	// contains filtered or unexported fields
}

func (*ActivationsCountResponse) Descriptor deprecated 

func (*ActivationsCountResponse) Descriptor() ([]byte, []int)

Deprecated: Use ActivationsCountResponse.ProtoReflect.Descriptor instead.

func (*ActivationsCountResponse) GetCount 

func (x *ActivationsCountResponse) GetCount() uint32

func (*ActivationsCountResponse) ProtoMessage 

func (*ActivationsCountResponse) ProtoMessage()

func (*ActivationsCountResponse) ProtoReflect 

func (x *ActivationsCountResponse) ProtoReflect() protoreflect.Message

func (*ActivationsCountResponse) Reset 

func (x *ActivationsCountResponse) Reset()

func (*ActivationsCountResponse) String 

func (x *ActivationsCountResponse) String() string

type Block 

type Block struct {
	Id []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // block hash
	// contains filtered or unexported fields
}

func (*Block) Descriptor deprecated 

func (*Block) Descriptor() ([]byte, []int)

Deprecated: Use Block.ProtoReflect.Descriptor instead.

func (*Block) GetId 

func (x *Block) GetId() []byte

func (*Block) ProtoMessage 

func (*Block) ProtoMessage()

func (*Block) ProtoReflect 

func (x *Block) ProtoReflect() protoreflect.Message

func (*Block) Reset 

func (x *Block) Reset()

func (*Block) String 

func (x *Block) String() string

type ContentsDrainVault 

type ContentsDrainVault struct {
	Vault       string `protobuf:"bytes,1,opt,name=vault,proto3" json:"vault,omitempty"`
	Destination string `protobuf:"bytes,2,opt,name=destination,proto3" json:"destination,omitempty"`
	Amount      uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
	// contains filtered or unexported fields
}

func (*ContentsDrainVault) Descriptor deprecated 

func (*ContentsDrainVault) Descriptor() ([]byte, []int)

Deprecated: Use ContentsDrainVault.ProtoReflect.Descriptor instead.

func (*ContentsDrainVault) GetAmount 

func (x *ContentsDrainVault) GetAmount() uint64

func (*ContentsDrainVault) GetDestination 

func (x *ContentsDrainVault) GetDestination() string

func (*ContentsDrainVault) GetVault 

func (x *ContentsDrainVault) GetVault() string

func (*ContentsDrainVault) ProtoMessage 

func (*ContentsDrainVault) ProtoMessage()

func (*ContentsDrainVault) ProtoReflect 

func (x *ContentsDrainVault) ProtoReflect() protoreflect.Message

func (*ContentsDrainVault) Reset 

func (x *ContentsDrainVault) Reset()

func (*ContentsDrainVault) String 

func (x *ContentsDrainVault) String() string

type ContentsMultiSigSpawn 

type ContentsMultiSigSpawn struct {
	Required uint32   `protobuf:"varint,1,opt,name=required,proto3" json:"required,omitempty"` // number of required signatures
	Pubkey   []string `protobuf:"bytes,2,rep,name=pubkey,proto3" json:"pubkey,omitempty"`
	// contains filtered or unexported fields
}

func (*ContentsMultiSigSpawn) Descriptor deprecated 

func (*ContentsMultiSigSpawn) Descriptor() ([]byte, []int)

Deprecated: Use ContentsMultiSigSpawn.ProtoReflect.Descriptor instead.

func (*ContentsMultiSigSpawn) GetPubkey 

func (x *ContentsMultiSigSpawn) GetPubkey() []string

func (*ContentsMultiSigSpawn) GetRequired 

func (x *ContentsMultiSigSpawn) GetRequired() uint32

func (*ContentsMultiSigSpawn) ProtoMessage 

func (*ContentsMultiSigSpawn) ProtoMessage()

func (*ContentsMultiSigSpawn) ProtoReflect 

func (x *ContentsMultiSigSpawn) ProtoReflect() protoreflect.Message

func (*ContentsMultiSigSpawn) Reset 

func (x *ContentsMultiSigSpawn) Reset()

func (*ContentsMultiSigSpawn) String 

func (x *ContentsMultiSigSpawn) String() string

type ContentsSend 

type ContentsSend struct {
	Destination string `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"` // recipient account
	Amount      uint64 `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty"`          // amount in smidge
	// contains filtered or unexported fields
}

func (*ContentsSend) Descriptor deprecated 

func (*ContentsSend) Descriptor() ([]byte, []int)

Deprecated: Use ContentsSend.ProtoReflect.Descriptor instead.

func (*ContentsSend) GetAmount 

func (x *ContentsSend) GetAmount() uint64

func (*ContentsSend) GetDestination 

func (x *ContentsSend) GetDestination() string

func (*ContentsSend) ProtoMessage 

func (*ContentsSend) ProtoMessage()

func (*ContentsSend) ProtoReflect 

func (x *ContentsSend) ProtoReflect() protoreflect.Message

func (*ContentsSend) Reset 

func (x *ContentsSend) Reset()

func (*ContentsSend) String 

func (x *ContentsSend) String() string

type ContentsSingleSigSpawn 

type ContentsSingleSigSpawn struct {
	Pubkey string `protobuf:"bytes,1,opt,name=pubkey,proto3" json:"pubkey,omitempty"`
	// contains filtered or unexported fields
}

func (*ContentsSingleSigSpawn) Descriptor deprecated 

func (*ContentsSingleSigSpawn) Descriptor() ([]byte, []int)

Deprecated: Use ContentsSingleSigSpawn.ProtoReflect.Descriptor instead.

func (*ContentsSingleSigSpawn) GetPubkey 

func (x *ContentsSingleSigSpawn) GetPubkey() string

func (*ContentsSingleSigSpawn) ProtoMessage 

func (*ContentsSingleSigSpawn) ProtoMessage()

func (*ContentsSingleSigSpawn) ProtoReflect 

func (x *ContentsSingleSigSpawn) ProtoReflect() protoreflect.Message

func (*ContentsSingleSigSpawn) Reset 

func (x *ContentsSingleSigSpawn) Reset()

func (*ContentsSingleSigSpawn) String 

func (x *ContentsSingleSigSpawn) String() string

type ContentsVaultSpawn 

type ContentsVaultSpawn struct {
	Owner               string `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"` // owner account
	TotalAmount         uint64 `protobuf:"varint,2,opt,name=total_amount,json=totalAmount,proto3" json:"total_amount,omitempty"`
	InitialUnlockAmount uint64 `protobuf:"varint,3,opt,name=initial_unlock_amount,json=initialUnlockAmount,proto3" json:"initial_unlock_amount,omitempty"`
	VestingStart        uint32 `protobuf:"varint,4,opt,name=vesting_start,json=vestingStart,proto3" json:"vesting_start,omitempty"` // as layer number
	VestingEnd          uint32 `protobuf:"varint,5,opt,name=vesting_end,json=vestingEnd,proto3" json:"vesting_end,omitempty"`       // as layer number
	// contains filtered or unexported fields
}

func (*ContentsVaultSpawn) Descriptor deprecated 

func (*ContentsVaultSpawn) Descriptor() ([]byte, []int)

Deprecated: Use ContentsVaultSpawn.ProtoReflect.Descriptor instead.

func (*ContentsVaultSpawn) GetInitialUnlockAmount 

func (x *ContentsVaultSpawn) GetInitialUnlockAmount() uint64

func (*ContentsVaultSpawn) GetOwner 

func (x *ContentsVaultSpawn) GetOwner() string

func (*ContentsVaultSpawn) GetTotalAmount 

func (x *ContentsVaultSpawn) GetTotalAmount() uint64

func (*ContentsVaultSpawn) GetVestingEnd 

func (x *ContentsVaultSpawn) GetVestingEnd() uint32

func (*ContentsVaultSpawn) GetVestingStart 

func (x *ContentsVaultSpawn) GetVestingStart() uint32

func (*ContentsVaultSpawn) ProtoMessage 

func (*ContentsVaultSpawn) ProtoMessage()

func (*ContentsVaultSpawn) ProtoReflect 

func (x *ContentsVaultSpawn) ProtoReflect() protoreflect.Message

func (*ContentsVaultSpawn) Reset 

func (x *ContentsVaultSpawn) Reset()

func (*ContentsVaultSpawn) String 

func (x *ContentsVaultSpawn) String() string

type EstimateGasRequest 

type EstimateGasRequest struct {
	Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` // signed binary transaction
	// contains filtered or unexported fields
}

func (*EstimateGasRequest) Descriptor deprecated 

func (*EstimateGasRequest) Descriptor() ([]byte, []int)

Deprecated: Use EstimateGasRequest.ProtoReflect.Descriptor instead.

func (*EstimateGasRequest) GetTransaction 

func (x *EstimateGasRequest) GetTransaction() []byte

func (*EstimateGasRequest) ProtoMessage 

func (*EstimateGasRequest) ProtoMessage()

func (*EstimateGasRequest) ProtoReflect 

func (x *EstimateGasRequest) ProtoReflect() protoreflect.Message

func (*EstimateGasRequest) Reset 

func (x *EstimateGasRequest) Reset()

func (*EstimateGasRequest) String 

func (x *EstimateGasRequest) String() string

type EstimateGasResponse 

type EstimateGasResponse struct {
	Status            *status.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	RecommendedMaxGas uint64         `protobuf:"varint,2,opt,name=recommended_max_gas,json=recommendedMaxGas,proto3" json:"recommended_max_gas,omitempty"` // recommended max gas
	// contains filtered or unexported fields
}

func (*EstimateGasResponse) Descriptor deprecated 

func (*EstimateGasResponse) Descriptor() ([]byte, []int)

Deprecated: Use EstimateGasResponse.ProtoReflect.Descriptor instead.

func (*EstimateGasResponse) GetRecommendedMaxGas 

func (x *EstimateGasResponse) GetRecommendedMaxGas() uint64

func (*EstimateGasResponse) GetStatus 

func (x *EstimateGasResponse) GetStatus() *status.Status

func (*EstimateGasResponse) ProtoMessage 

func (*EstimateGasResponse) ProtoMessage()

func (*EstimateGasResponse) ProtoReflect 

func (x *EstimateGasResponse) ProtoReflect() protoreflect.Message

func (*EstimateGasResponse) Reset 

func (x *EstimateGasResponse) Reset()

func (*EstimateGasResponse) String 

func (x *EstimateGasResponse) String() string

type HighestRequest 

type HighestRequest struct {
	// contains filtered or unexported fields
}

func (*HighestRequest) Descriptor deprecated 

func (*HighestRequest) Descriptor() ([]byte, []int)

Deprecated: Use HighestRequest.ProtoReflect.Descriptor instead.

func (*HighestRequest) ProtoMessage 

func (*HighestRequest) ProtoMessage()

func (*HighestRequest) ProtoReflect 

func (x *HighestRequest) ProtoReflect() protoreflect.Message

func (*HighestRequest) Reset 

func (x *HighestRequest) Reset()

func (*HighestRequest) String 

func (x *HighestRequest) String() string

type HighestResponse 

type HighestResponse struct {
	Activation *Activation `protobuf:"bytes,1,opt,name=activation,proto3" json:"activation,omitempty"`
	// contains filtered or unexported fields
}

func (*HighestResponse) Descriptor deprecated 

func (*HighestResponse) Descriptor() ([]byte, []int)

Deprecated: Use HighestResponse.ProtoReflect.Descriptor instead.

func (*HighestResponse) GetActivation 

func (x *HighestResponse) GetActivation() *Activation

func (*HighestResponse) ProtoMessage 

func (*HighestResponse) ProtoMessage()

func (*HighestResponse) ProtoReflect 

func (x *HighestResponse) ProtoReflect() protoreflect.Message

func (*HighestResponse) Reset 

func (x *HighestResponse) Reset()

func (*HighestResponse) String 

func (x *HighestResponse) String() string

type Layer 

type Layer struct {
	Number              uint32            `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"` // layer number - not hash - layer content may change
	Status              Layer_LayerStatus `protobuf:"varint,2,opt,name=status,proto3,enum=spacemesh.v2beta1.Layer_LayerStatus" json:"status,omitempty"`
	ConsensusHash       string            `protobuf:"bytes,3,opt,name=consensus_hash,json=consensusHash,proto3" json:"consensus_hash,omitempty"`
	StateHash           []byte            `protobuf:"bytes,4,opt,name=state_hash,json=stateHash,proto3" json:"state_hash,omitempty"`                                 // fingerprint of the computed state at the layer
	CumulativeStateHash []byte            `protobuf:"bytes,5,opt,name=cumulative_state_hash,json=cumulativeStateHash,proto3" json:"cumulative_state_hash,omitempty"` // cumulative fingerprint that uniquely identifies state since genesis
	Block               *Block            `protobuf:"bytes,6,opt,name=block,proto3" json:"block,omitempty"`                                                          // layer's block
	// contains filtered or unexported fields
}

func (*Layer) Descriptor deprecated 

func (*Layer) Descriptor() ([]byte, []int)

Deprecated: Use Layer.ProtoReflect.Descriptor instead.

func (*Layer) GetBlock 

func (x *Layer) GetBlock() *Block

func (*Layer) GetConsensusHash 

func (x *Layer) GetConsensusHash() string

func (*Layer) GetCumulativeStateHash 

func (x *Layer) GetCumulativeStateHash() []byte

func (*Layer) GetNumber 

func (x *Layer) GetNumber() uint32

func (*Layer) GetStateHash 

func (x *Layer) GetStateHash() []byte

func (*Layer) GetStatus 

func (x *Layer) GetStatus() Layer_LayerStatus

func (*Layer) ProtoMessage 

func (*Layer) ProtoMessage()

func (*Layer) ProtoReflect 

func (x *Layer) ProtoReflect() protoreflect.Message

func (*Layer) Reset 

func (x *Layer) Reset()

func (*Layer) String 

func (x *Layer) String() string

type LayerList 

type LayerList struct {
	Layers []*Layer `protobuf:"bytes,1,rep,name=layers,proto3" json:"layers,omitempty"` // list of layers
	// contains filtered or unexported fields
}

func (*LayerList) Descriptor deprecated 

func (*LayerList) Descriptor() ([]byte, []int)

Deprecated: Use LayerList.ProtoReflect.Descriptor instead.

func (*LayerList) GetLayers 

func (x *LayerList) GetLayers() []*Layer

func (*LayerList) ProtoMessage 

func (*LayerList) ProtoMessage()

func (*LayerList) ProtoReflect 

func (x *LayerList) ProtoReflect() protoreflect.Message

func (*LayerList) Reset 

func (x *LayerList) Reset()

func (*LayerList) String 

func (x *LayerList) String() string

type LayerRequest 

type LayerRequest struct {
	StartLayer uint32    `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`                               // starting layer for the query
	EndLayer   uint32    `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`                                     // ending layer for the query
	Offset     uint64    `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`                                                         // adjusts the starting point for data
	Limit      uint64    `protobuf:"varint,4,opt,name=limit,proto3" json:"limit,omitempty"`                                                           // specifies max number of items to fetch
	SortOrder  SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=spacemesh.v2beta1.SortOrder" json:"sort_order,omitempty"` // specifies the sort order (default is ASC)
	// contains filtered or unexported fields
}

func (*LayerRequest) Descriptor deprecated 

func (*LayerRequest) Descriptor() ([]byte, []int)

Deprecated: Use LayerRequest.ProtoReflect.Descriptor instead.

func (*LayerRequest) GetEndLayer 

func (x *LayerRequest) GetEndLayer() uint32

func (*LayerRequest) GetLimit 

func (x *LayerRequest) GetLimit() uint64

func (*LayerRequest) GetOffset 

func (x *LayerRequest) GetOffset() uint64

func (*LayerRequest) GetSortOrder 

func (x *LayerRequest) GetSortOrder() SortOrder

func (*LayerRequest) GetStartLayer 

func (x *LayerRequest) GetStartLayer() uint32

func (*LayerRequest) ProtoMessage 

func (*LayerRequest) ProtoMessage()

func (*LayerRequest) ProtoReflect 

func (x *LayerRequest) ProtoReflect() protoreflect.Message

func (*LayerRequest) Reset 

func (x *LayerRequest) Reset()

func (*LayerRequest) String 

func (x *LayerRequest) String() string

type LayerServiceClient 

type LayerServiceClient interface {
	// List of layers
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of layers based on the provided request parameters.
	List(ctx context.Context, in *LayerRequest, opts ...grpc.CallOption) (*LayerList, error)
}

LayerServiceClient is the client API for LayerService 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.

func NewLayerServiceClient 

func NewLayerServiceClient(cc grpc.ClientConnInterface) LayerServiceClient

type LayerServiceServer 

type LayerServiceServer interface {
	// List of layers
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of layers based on the provided request parameters.
	List(context.Context, *LayerRequest) (*LayerList, error)
}

LayerServiceServer is the server API for LayerService service. All implementations should embed UnimplementedLayerServiceServer for forward compatibility

type LayerStreamRequest 

type LayerStreamRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	Watch      bool   `protobuf:"varint,3,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

func (*LayerStreamRequest) Descriptor deprecated 

func (*LayerStreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use LayerStreamRequest.ProtoReflect.Descriptor instead.

func (*LayerStreamRequest) GetEndLayer 

func (x *LayerStreamRequest) GetEndLayer() uint32

func (*LayerStreamRequest) GetStartLayer 

func (x *LayerStreamRequest) GetStartLayer() uint32

func (*LayerStreamRequest) GetWatch 

func (x *LayerStreamRequest) GetWatch() bool

func (*LayerStreamRequest) ProtoMessage 

func (*LayerStreamRequest) ProtoMessage()

func (*LayerStreamRequest) ProtoReflect 

func (x *LayerStreamRequest) ProtoReflect() protoreflect.Message

func (*LayerStreamRequest) Reset 

func (x *LayerStreamRequest) Reset()

func (*LayerStreamRequest) String 

func (x *LayerStreamRequest) String() string

type LayerStreamServiceClient 

type LayerStreamServiceClient interface {
	Stream(ctx context.Context, in *LayerStreamRequest, opts ...grpc.CallOption) (LayerStreamService_StreamClient, error)
}

LayerStreamServiceClient is the client API for LayerStreamService 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.

func NewLayerStreamServiceClient 

func NewLayerStreamServiceClient(cc grpc.ClientConnInterface) LayerStreamServiceClient

type LayerStreamServiceServer 

type LayerStreamServiceServer interface {
	Stream(*LayerStreamRequest, LayerStreamService_StreamServer) error
}

LayerStreamServiceServer is the server API for LayerStreamService service. All implementations should embed UnimplementedLayerStreamServiceServer for forward compatibility

type LayerStreamService_StreamClient 

type LayerStreamService_StreamClient interface {
	Recv() (*Layer, error)
	grpc.ClientStream
}

type LayerStreamService_StreamServer 

type LayerStreamService_StreamServer interface {
	Send(*Layer) error
	grpc.ServerStream
}

type Layer_LayerStatus 

type Layer_LayerStatus int32
const (
	Layer_LAYER_STATUS_UNSPECIFIED Layer_LayerStatus = 0
	Layer_LAYER_STATUS_APPLIED     Layer_LayerStatus = 1 // applied by hare
	Layer_LAYER_STATUS_VERIFIED    Layer_LayerStatus = 2 // verified by tortoise
)

func (Layer_LayerStatus) Descriptor 

func (Layer_LayerStatus) Descriptor() protoreflect.EnumDescriptor

func (Layer_LayerStatus) Enum 

func (x Layer_LayerStatus) Enum() *Layer_LayerStatus

func (Layer_LayerStatus) EnumDescriptor deprecated 

func (Layer_LayerStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use Layer_LayerStatus.Descriptor instead.

func (Layer_LayerStatus) Number 

func (x Layer_LayerStatus) Number() protoreflect.EnumNumber

func (Layer_LayerStatus) String 

func (x Layer_LayerStatus) String() string

func (Layer_LayerStatus) Type 

func (Layer_LayerStatus) Type() protoreflect.EnumType

type MalfeasanceList 

type MalfeasanceList struct {
	Proofs []*MalfeasanceProof `protobuf:"bytes,1,rep,name=proofs,proto3" json:"proofs,omitempty"` // list of malfeasance proofs
	// contains filtered or unexported fields
}

func (*MalfeasanceList) Descriptor deprecated 

func (*MalfeasanceList) Descriptor() ([]byte, []int)

Deprecated: Use MalfeasanceList.ProtoReflect.Descriptor instead.

func (*MalfeasanceList) GetProofs 

func (x *MalfeasanceList) GetProofs() []*MalfeasanceProof

func (*MalfeasanceList) ProtoMessage 

func (*MalfeasanceList) ProtoMessage()

func (*MalfeasanceList) ProtoReflect 

func (x *MalfeasanceList) ProtoReflect() protoreflect.Message

func (*MalfeasanceList) Reset 

func (x *MalfeasanceList) Reset()

func (*MalfeasanceList) String 

func (x *MalfeasanceList) String() string

type MalfeasanceProof 

type MalfeasanceProof struct {
	Smesher []byte                             `protobuf:"bytes,1,opt,name=smesher,proto3" json:"smesher,omitempty"`
	Domain  MalfeasanceProof_MalfeasanceDomain `protobuf:"varint,2,opt,name=domain,proto3,enum=spacemesh.v2beta1.MalfeasanceProof_MalfeasanceDomain" json:"domain,omitempty"`
	// type of the malfeasance proof, depends on domain
	//
	// for legacy proofs the types are
	//
	//	1 - Double publish of ATX
	//	2 - Multiple ballots for a layer by same smesher
	//	3 - Hare Equivocation (currently unused)
	//	4 - ATX with invalid PoST proof published
	//	5 - ATX referencing an invalid previous ATX published
	Type uint32 `protobuf:"varint,3,opt,name=type,proto3" json:"type,omitempty"`
	// Properties of the Malfeasance proof, different for every type of proof
	Properties map[string]string `` /* 161-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*MalfeasanceProof) Descriptor deprecated 

func (*MalfeasanceProof) Descriptor() ([]byte, []int)

Deprecated: Use MalfeasanceProof.ProtoReflect.Descriptor instead.

func (*MalfeasanceProof) GetDomain 

func (x *MalfeasanceProof) GetDomain() MalfeasanceProof_MalfeasanceDomain

func (*MalfeasanceProof) GetProperties 

func (x *MalfeasanceProof) GetProperties() map[string]string

func (*MalfeasanceProof) GetSmesher 

func (x *MalfeasanceProof) GetSmesher() []byte

func (*MalfeasanceProof) GetType 

func (x *MalfeasanceProof) GetType() uint32

func (*MalfeasanceProof) ProtoMessage 

func (*MalfeasanceProof) ProtoMessage()

func (*MalfeasanceProof) ProtoReflect 

func (x *MalfeasanceProof) ProtoReflect() protoreflect.Message

func (*MalfeasanceProof) Reset 

func (x *MalfeasanceProof) Reset()

func (*MalfeasanceProof) String 

func (x *MalfeasanceProof) String() string

type MalfeasanceProof_MalfeasanceDomain 

type MalfeasanceProof_MalfeasanceDomain int32
const (
	MalfeasanceProof_DOMAIN_UNSPECIFIED MalfeasanceProof_MalfeasanceDomain = 0 // for legacy proofs
	MalfeasanceProof_DOMAIN_ACTIVATION  MalfeasanceProof_MalfeasanceDomain = 1 // ATX related proofs
	MalfeasanceProof_DOMAIN_BALLOT      MalfeasanceProof_MalfeasanceDomain = 2 // Ballot related proofs
	MalfeasanceProof_DOMAIN_HARE        MalfeasanceProof_MalfeasanceDomain = 3 // Hare related proofs
)

func (MalfeasanceProof_MalfeasanceDomain) Descriptor 

func (MalfeasanceProof_MalfeasanceDomain) Descriptor() protoreflect.EnumDescriptor

func (MalfeasanceProof_MalfeasanceDomain) Enum 

func (x MalfeasanceProof_MalfeasanceDomain) Enum() *MalfeasanceProof_MalfeasanceDomain

func (MalfeasanceProof_MalfeasanceDomain) EnumDescriptor deprecated 

func (MalfeasanceProof_MalfeasanceDomain) EnumDescriptor() ([]byte, []int)

Deprecated: Use MalfeasanceProof_MalfeasanceDomain.Descriptor instead.

func (MalfeasanceProof_MalfeasanceDomain) Number 

func (x MalfeasanceProof_MalfeasanceDomain) Number() protoreflect.EnumNumber

func (MalfeasanceProof_MalfeasanceDomain) String 

func (x MalfeasanceProof_MalfeasanceDomain) String() string

func (MalfeasanceProof_MalfeasanceDomain) Type 

func (MalfeasanceProof_MalfeasanceDomain) Type() protoreflect.EnumType

type MalfeasanceRequest 

type MalfeasanceRequest struct {
	SmesherId [][]byte `protobuf:"bytes,1,rep,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"` // list of smesher ids to fetch (can be empty for all)
	Offset    uint64   `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`                       // adjusts the starting point for data
	Limit     uint64   `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`                         // specifies max number of items to fetch
	// contains filtered or unexported fields
}

func (*MalfeasanceRequest) Descriptor deprecated 

func (*MalfeasanceRequest) Descriptor() ([]byte, []int)

Deprecated: Use MalfeasanceRequest.ProtoReflect.Descriptor instead.

func (*MalfeasanceRequest) GetLimit 

func (x *MalfeasanceRequest) GetLimit() uint64

func (*MalfeasanceRequest) GetOffset 

func (x *MalfeasanceRequest) GetOffset() uint64

func (*MalfeasanceRequest) GetSmesherId 

func (x *MalfeasanceRequest) GetSmesherId() [][]byte

func (*MalfeasanceRequest) ProtoMessage 

func (*MalfeasanceRequest) ProtoMessage()

func (*MalfeasanceRequest) ProtoReflect 

func (x *MalfeasanceRequest) ProtoReflect() protoreflect.Message

func (*MalfeasanceRequest) Reset 

func (x *MalfeasanceRequest) Reset()

func (*MalfeasanceRequest) String 

func (x *MalfeasanceRequest) String() string

type MalfeasanceServiceClient 

type MalfeasanceServiceClient interface {
	// List of malfeasance proofs
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of malfeasance proofs based on the provided request parameters.
	List(ctx context.Context, in *MalfeasanceRequest, opts ...grpc.CallOption) (*MalfeasanceList, error)
}

MalfeasanceServiceClient is the client API for MalfeasanceService 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.

func NewMalfeasanceServiceClient 

func NewMalfeasanceServiceClient(cc grpc.ClientConnInterface) MalfeasanceServiceClient

type MalfeasanceServiceServer 

type MalfeasanceServiceServer interface {
	// List of malfeasance proofs
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of malfeasance proofs based on the provided request parameters.
	List(context.Context, *MalfeasanceRequest) (*MalfeasanceList, error)
}

MalfeasanceServiceServer is the server API for MalfeasanceService service. All implementations should embed UnimplementedMalfeasanceServiceServer for forward compatibility

type MalfeasanceStreamRequest 

type MalfeasanceStreamRequest struct {
	SmesherId [][]byte `protobuf:"bytes,1,rep,name=smesher_id,json=smesherId,proto3" json:"smesher_id,omitempty"` // list of smesher ids to watch
	Watch     bool     `protobuf:"varint,2,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

func (*MalfeasanceStreamRequest) Descriptor deprecated 

func (*MalfeasanceStreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use MalfeasanceStreamRequest.ProtoReflect.Descriptor instead.

func (*MalfeasanceStreamRequest) GetSmesherId 

func (x *MalfeasanceStreamRequest) GetSmesherId() [][]byte

func (*MalfeasanceStreamRequest) GetWatch 

func (x *MalfeasanceStreamRequest) GetWatch() bool

func (*MalfeasanceStreamRequest) ProtoMessage 

func (*MalfeasanceStreamRequest) ProtoMessage()

func (*MalfeasanceStreamRequest) ProtoReflect 

func (x *MalfeasanceStreamRequest) ProtoReflect() protoreflect.Message

func (*MalfeasanceStreamRequest) Reset 

func (x *MalfeasanceStreamRequest) Reset()

func (*MalfeasanceStreamRequest) String 

func (x *MalfeasanceStreamRequest) String() string

type MalfeasanceStreamServiceClient 

type MalfeasanceStreamServiceClient interface {
	Stream(ctx context.Context, in *MalfeasanceStreamRequest, opts ...grpc.CallOption) (MalfeasanceStreamService_StreamClient, error)
}

MalfeasanceStreamServiceClient is the client API for MalfeasanceStreamService 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.

func NewMalfeasanceStreamServiceClient 

func NewMalfeasanceStreamServiceClient(cc grpc.ClientConnInterface) MalfeasanceStreamServiceClient

type MalfeasanceStreamServiceServer 

type MalfeasanceStreamServiceServer interface {
	Stream(*MalfeasanceStreamRequest, MalfeasanceStreamService_StreamServer) error
}

MalfeasanceStreamServiceServer is the server API for MalfeasanceStreamService service. All implementations should embed UnimplementedMalfeasanceStreamServiceServer for forward compatibility

type MalfeasanceStreamService_StreamClient 

type MalfeasanceStreamService_StreamClient interface {
	Recv() (*MalfeasanceProof, error)
	grpc.ClientStream
}

type MalfeasanceStreamService_StreamServer 

type MalfeasanceStreamService_StreamServer interface {
	Send(*MalfeasanceProof) error
	grpc.ServerStream
}

type NetworkInfoRequest 

type NetworkInfoRequest struct {
	// contains filtered or unexported fields
}

func (*NetworkInfoRequest) Descriptor deprecated 

func (*NetworkInfoRequest) Descriptor() ([]byte, []int)

Deprecated: Use NetworkInfoRequest.ProtoReflect.Descriptor instead.

func (*NetworkInfoRequest) ProtoMessage 

func (*NetworkInfoRequest) ProtoMessage()

func (*NetworkInfoRequest) ProtoReflect 

func (x *NetworkInfoRequest) ProtoReflect() protoreflect.Message

func (*NetworkInfoRequest) Reset 

func (x *NetworkInfoRequest) Reset()

func (*NetworkInfoRequest) String 

func (x *NetworkInfoRequest) String() string

type NetworkInfoResponse 

type NetworkInfoResponse struct {
	GenesisTime           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=genesis_time,json=genesisTime,proto3" json:"genesis_time,omitempty"`       // genesis time of the network, represented as a timestamp
	LayerDuration         *durationpb.Duration   `protobuf:"bytes,3,opt,name=layer_duration,json=layerDuration,proto3" json:"layer_duration,omitempty"` // duration of each layer in the network, specified as a duration
	GenesisId             []byte                 `protobuf:"bytes,4,opt,name=genesis_id,json=genesisId,proto3" json:"genesis_id,omitempty"`
	Hrp                   string                 `protobuf:"bytes,5,opt,name=hrp,proto3" json:"hrp,omitempty"`
	EffectiveGenesisLayer uint32                 `` // effective genesis layer, i.e., first layer after genesis initialization period
	/* 127-byte string literal not displayed */
	LayersPerEpoch uint32 `protobuf:"varint,7,opt,name=layers_per_epoch,json=layersPerEpoch,proto3" json:"layers_per_epoch,omitempty"` // number of layers per epoch
	LabelsPerUnit  uint64 `protobuf:"varint,8,opt,name=labels_per_unit,json=labelsPerUnit,proto3" json:"labels_per_unit,omitempty"`    // number of labels per unit
	// contains filtered or unexported fields
}

func (*NetworkInfoResponse) Descriptor deprecated 

func (*NetworkInfoResponse) Descriptor() ([]byte, []int)

Deprecated: Use NetworkInfoResponse.ProtoReflect.Descriptor instead.

func (*NetworkInfoResponse) GetEffectiveGenesisLayer 

func (x *NetworkInfoResponse) GetEffectiveGenesisLayer() uint32

func (*NetworkInfoResponse) GetGenesisId 

func (x *NetworkInfoResponse) GetGenesisId() []byte

func (*NetworkInfoResponse) GetGenesisTime 

func (x *NetworkInfoResponse) GetGenesisTime() *timestamppb.Timestamp

func (*NetworkInfoResponse) GetHrp 

func (x *NetworkInfoResponse) GetHrp() string

func (*NetworkInfoResponse) GetLabelsPerUnit 

func (x *NetworkInfoResponse) GetLabelsPerUnit() uint64

func (*NetworkInfoResponse) GetLayerDuration 

func (x *NetworkInfoResponse) GetLayerDuration() *durationpb.Duration

func (*NetworkInfoResponse) GetLayersPerEpoch 

func (x *NetworkInfoResponse) GetLayersPerEpoch() uint32

func (*NetworkInfoResponse) ProtoMessage 

func (*NetworkInfoResponse) ProtoMessage()

func (*NetworkInfoResponse) ProtoReflect 

func (x *NetworkInfoResponse) ProtoReflect() protoreflect.Message

func (*NetworkInfoResponse) Reset 

func (x *NetworkInfoResponse) Reset()

func (*NetworkInfoResponse) String 

func (x *NetworkInfoResponse) String() string

type NetworkServiceClient 

type NetworkServiceClient interface {
	// Network information
	//
	// Info is a method that returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve network information.
	Info(ctx context.Context, in *NetworkInfoRequest, opts ...grpc.CallOption) (*NetworkInfoResponse, error)
}

NetworkServiceClient is the client API for NetworkService 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.

func NewNetworkServiceClient 

func NewNetworkServiceClient(cc grpc.ClientConnInterface) NetworkServiceClient

type NetworkServiceServer 

type NetworkServiceServer interface {
	// Network information
	//
	// Info is a method that returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve network information.
	Info(context.Context, *NetworkInfoRequest) (*NetworkInfoResponse, error)
}

NetworkServiceServer is the server API for NetworkService service. All implementations should embed UnimplementedNetworkServiceServer for forward compatibility

type NodeServiceClient 

type NodeServiceClient interface {
	// Node status
	//
	// Status is a method that returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve node status information.
	Status(ctx context.Context, in *NodeStatusRequest, opts ...grpc.CallOption) (*NodeStatusResponse, error)
}

NodeServiceClient is the client API for NodeService 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.

func NewNodeServiceClient 

func NewNodeServiceClient(cc grpc.ClientConnInterface) NodeServiceClient

type NodeServiceServer 

type NodeServiceServer interface {
	// Node status
	//
	// Status is a method that returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve node status information.
	Status(context.Context, *NodeStatusRequest) (*NodeStatusResponse, error)
}

NodeServiceServer is the server API for NodeService service. All implementations should embed UnimplementedNodeServiceServer for forward compatibility

type NodeStatusRequest 

type NodeStatusRequest struct {
	// contains filtered or unexported fields
}

func (*NodeStatusRequest) Descriptor deprecated 

func (*NodeStatusRequest) Descriptor() ([]byte, []int)

Deprecated: Use NodeStatusRequest.ProtoReflect.Descriptor instead.

func (*NodeStatusRequest) ProtoMessage 

func (*NodeStatusRequest) ProtoMessage()

func (*NodeStatusRequest) ProtoReflect 

func (x *NodeStatusRequest) ProtoReflect() protoreflect.Message

func (*NodeStatusRequest) Reset 

func (x *NodeStatusRequest) Reset()

func (*NodeStatusRequest) String 

func (x *NodeStatusRequest) String() string

type NodeStatusResponse 

type NodeStatusResponse struct {
	ConnectedPeers uint64                        `protobuf:"varint,1,opt,name=connected_peers,json=connectedPeers,proto3" json:"connected_peers,omitempty"`                // number of connected neighbors
	Status         NodeStatusResponse_SyncStatus `protobuf:"varint,2,opt,name=status,proto3,enum=spacemesh.v2beta1.NodeStatusResponse_SyncStatus" json:"status,omitempty"` // node sync status
	LatestLayer    uint32                        `protobuf:"varint,3,opt,name=latest_layer,json=latestLayer,proto3" json:"latest_layer,omitempty"`                         // latest layer node has seen from blocks
	AppliedLayer   uint32                        `protobuf:"varint,4,opt,name=applied_layer,json=appliedLayer,proto3" json:"applied_layer,omitempty"`                      // last layer node has applied to the state
	ProcessedLayer uint32                        `protobuf:"varint,5,opt,name=processed_layer,json=processedLayer,proto3" json:"processed_layer,omitempty"`                // last layer whose votes have been processed
	CurrentLayer   uint32                        `protobuf:"varint,6,opt,name=current_layer,json=currentLayer,proto3" json:"current_layer,omitempty"`                      // current layer, based on clock time
	// contains filtered or unexported fields
}

func (*NodeStatusResponse) Descriptor deprecated 

func (*NodeStatusResponse) Descriptor() ([]byte, []int)

Deprecated: Use NodeStatusResponse.ProtoReflect.Descriptor instead.

func (*NodeStatusResponse) GetAppliedLayer 

func (x *NodeStatusResponse) GetAppliedLayer() uint32

func (*NodeStatusResponse) GetConnectedPeers 

func (x *NodeStatusResponse) GetConnectedPeers() uint64

func (*NodeStatusResponse) GetCurrentLayer 

func (x *NodeStatusResponse) GetCurrentLayer() uint32

func (*NodeStatusResponse) GetLatestLayer 

func (x *NodeStatusResponse) GetLatestLayer() uint32

func (*NodeStatusResponse) GetProcessedLayer 

func (x *NodeStatusResponse) GetProcessedLayer() uint32

func (*NodeStatusResponse) GetStatus 

func (x *NodeStatusResponse) GetStatus() NodeStatusResponse_SyncStatus

func (*NodeStatusResponse) ProtoMessage 

func (*NodeStatusResponse) ProtoMessage()

func (*NodeStatusResponse) ProtoReflect 

func (x *NodeStatusResponse) ProtoReflect() protoreflect.Message

func (*NodeStatusResponse) Reset 

func (x *NodeStatusResponse) Reset()

func (*NodeStatusResponse) String 

func (x *NodeStatusResponse) String() string

type NodeStatusResponse_SyncStatus 

type NodeStatusResponse_SyncStatus int32
const (
	NodeStatusResponse_SYNC_STATUS_UNSPECIFIED NodeStatusResponse_SyncStatus = 0
	NodeStatusResponse_SYNC_STATUS_OFFLINE     NodeStatusResponse_SyncStatus = 1
	NodeStatusResponse_SYNC_STATUS_SYNCING     NodeStatusResponse_SyncStatus = 2
	NodeStatusResponse_SYNC_STATUS_SYNCED      NodeStatusResponse_SyncStatus = 3
)

func (NodeStatusResponse_SyncStatus) Descriptor 

func (NodeStatusResponse_SyncStatus) Descriptor() protoreflect.EnumDescriptor

func (NodeStatusResponse_SyncStatus) Enum 

func (x NodeStatusResponse_SyncStatus) Enum() *NodeStatusResponse_SyncStatus

func (NodeStatusResponse_SyncStatus) EnumDescriptor deprecated 

func (NodeStatusResponse_SyncStatus) EnumDescriptor() ([]byte, []int)

Deprecated: Use NodeStatusResponse_SyncStatus.Descriptor instead.

func (NodeStatusResponse_SyncStatus) Number 

func (x NodeStatusResponse_SyncStatus) Number() protoreflect.EnumNumber

func (NodeStatusResponse_SyncStatus) String 

func (x NodeStatusResponse_SyncStatus) String() string

func (NodeStatusResponse_SyncStatus) Type 

func (NodeStatusResponse_SyncStatus) Type() protoreflect.EnumType

type Nonce 

type Nonce struct {
	Counter uint64 `protobuf:"varint,1,opt,name=counter,proto3" json:"counter,omitempty"`
	// contains filtered or unexported fields
}

func (*Nonce) Descriptor deprecated 

func (*Nonce) Descriptor() ([]byte, []int)

Deprecated: Use Nonce.ProtoReflect.Descriptor instead.

func (*Nonce) GetCounter 

func (x *Nonce) GetCounter() uint64

func (*Nonce) ProtoMessage 

func (*Nonce) ProtoMessage()

func (*Nonce) ProtoReflect 

func (x *Nonce) ProtoReflect() protoreflect.Message

func (*Nonce) Reset 

func (x *Nonce) Reset()

func (*Nonce) String 

func (x *Nonce) String() string

type ParseTransactionRequest 

type ParseTransactionRequest struct {
	Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` // signed binary transaction
	Verify      bool   `protobuf:"varint,2,opt,name=verify,proto3" json:"verify,omitempty"`          // if true signature verification will be executed
	// contains filtered or unexported fields
}

func (*ParseTransactionRequest) Descriptor deprecated 

func (*ParseTransactionRequest) Descriptor() ([]byte, []int)

Deprecated: Use ParseTransactionRequest.ProtoReflect.Descriptor instead.

func (*ParseTransactionRequest) GetTransaction 

func (x *ParseTransactionRequest) GetTransaction() []byte

func (*ParseTransactionRequest) GetVerify 

func (x *ParseTransactionRequest) GetVerify() bool

func (*ParseTransactionRequest) ProtoMessage 

func (*ParseTransactionRequest) ProtoMessage()

func (*ParseTransactionRequest) ProtoReflect 

func (x *ParseTransactionRequest) ProtoReflect() protoreflect.Message

func (*ParseTransactionRequest) Reset 

func (x *ParseTransactionRequest) Reset()

func (*ParseTransactionRequest) String 

func (x *ParseTransactionRequest) String() string

type ParseTransactionResponse 

type ParseTransactionResponse struct {
	Status *status.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	Tx     *Transaction   `protobuf:"bytes,2,opt,name=tx,proto3" json:"tx,omitempty"` // parsed transaction
	// contains filtered or unexported fields
}

func (*ParseTransactionResponse) Descriptor deprecated 

func (*ParseTransactionResponse) Descriptor() ([]byte, []int)

Deprecated: Use ParseTransactionResponse.ProtoReflect.Descriptor instead.

func (*ParseTransactionResponse) GetStatus 

func (x *ParseTransactionResponse) GetStatus() *status.Status

func (*ParseTransactionResponse) GetTx 

func (x *ParseTransactionResponse) GetTx() *Transaction

func (*ParseTransactionResponse) ProtoMessage 

func (*ParseTransactionResponse) ProtoMessage()

func (*ParseTransactionResponse) ProtoReflect 

func (x *ParseTransactionResponse) ProtoReflect() protoreflect.Message

func (*ParseTransactionResponse) Reset 

func (x *ParseTransactionResponse) Reset()

func (*ParseTransactionResponse) String 

func (x *ParseTransactionResponse) String() string

type Reward 

type Reward struct {
	Layer       uint32 `protobuf:"varint,1,opt,name=layer,proto3" json:"layer,omitempty"`                                // layer award was paid in
	Total       uint64 `protobuf:"varint,2,opt,name=total,proto3" json:"total,omitempty"`                                // total reward paid in smidge (sum of tx fee and layer reward)
	LayerReward uint64 `protobuf:"varint,3,opt,name=layer_reward,json=layerReward,proto3" json:"layer_reward,omitempty"` // tx_fee = total - layer_reward
	Coinbase    string `protobuf:"bytes,5,opt,name=coinbase,proto3" json:"coinbase,omitempty"`                           // account awarded this reward
	Smesher     []byte `protobuf:"bytes,6,opt,name=smesher,proto3" json:"smesher,omitempty"`                             // id of smesher who earned this reward
	// contains filtered or unexported fields
}

func (*Reward) Descriptor deprecated 

func (*Reward) Descriptor() ([]byte, []int)

Deprecated: Use Reward.ProtoReflect.Descriptor instead.

func (*Reward) GetCoinbase 

func (x *Reward) GetCoinbase() string

func (*Reward) GetLayer 

func (x *Reward) GetLayer() uint32

func (*Reward) GetLayerReward 

func (x *Reward) GetLayerReward() uint64

func (*Reward) GetSmesher 

func (x *Reward) GetSmesher() []byte

func (*Reward) GetTotal 

func (x *Reward) GetTotal() uint64

func (*Reward) ProtoMessage 

func (*Reward) ProtoMessage()

func (*Reward) ProtoReflect 

func (x *Reward) ProtoReflect() protoreflect.Message

func (*Reward) Reset 

func (x *Reward) Reset()

func (*Reward) String 

func (x *Reward) String() string

type RewardList 

type RewardList struct {
	Rewards []*Reward `protobuf:"bytes,1,rep,name=rewards,proto3" json:"rewards,omitempty"` // list of rewards
	// contains filtered or unexported fields
}

func (*RewardList) Descriptor deprecated 

func (*RewardList) Descriptor() ([]byte, []int)

Deprecated: Use RewardList.ProtoReflect.Descriptor instead.

func (*RewardList) GetRewards 

func (x *RewardList) GetRewards() []*Reward

func (*RewardList) ProtoMessage 

func (*RewardList) ProtoMessage()

func (*RewardList) ProtoReflect 

func (x *RewardList) ProtoReflect() protoreflect.Message

func (*RewardList) Reset 

func (x *RewardList) Reset()

func (*RewardList) String 

func (x *RewardList) String() string

type RewardRequest 

type RewardRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"` // starting layer for the query
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`       // ending layer for the query
	// Types that are assignable to FilterBy:
	//
	//	*RewardRequest_Coinbase
	//	*RewardRequest_Smesher
	FilterBy  isRewardRequest_FilterBy `protobuf_oneof:"filter_by"`
	Offset    uint64                   `protobuf:"varint,5,opt,name=offset,proto3" json:"offset,omitempty"`                                                         // adjusts the starting point for data
	Limit     uint64                   `protobuf:"varint,6,opt,name=limit,proto3" json:"limit,omitempty"`                                                           // specifies max number of items to fetch
	SortOrder SortOrder                `protobuf:"varint,7,opt,name=sort_order,json=sortOrder,proto3,enum=spacemesh.v2beta1.SortOrder" json:"sort_order,omitempty"` // specifies the sort order by layer (default is ASC)
	// contains filtered or unexported fields
}

func (*RewardRequest) Descriptor deprecated 

func (*RewardRequest) Descriptor() ([]byte, []int)

Deprecated: Use RewardRequest.ProtoReflect.Descriptor instead.

func (*RewardRequest) GetCoinbase 

func (x *RewardRequest) GetCoinbase() string

func (*RewardRequest) GetEndLayer 

func (x *RewardRequest) GetEndLayer() uint32

func (*RewardRequest) GetFilterBy 

func (m *RewardRequest) GetFilterBy() isRewardRequest_FilterBy

func (*RewardRequest) GetLimit 

func (x *RewardRequest) GetLimit() uint64

func (*RewardRequest) GetOffset 

func (x *RewardRequest) GetOffset() uint64

func (*RewardRequest) GetSmesher 

func (x *RewardRequest) GetSmesher() []byte

func (*RewardRequest) GetSortOrder 

func (x *RewardRequest) GetSortOrder() SortOrder

func (*RewardRequest) GetStartLayer 

func (x *RewardRequest) GetStartLayer() uint32

func (*RewardRequest) ProtoMessage 

func (*RewardRequest) ProtoMessage()

func (*RewardRequest) ProtoReflect 

func (x *RewardRequest) ProtoReflect() protoreflect.Message

func (*RewardRequest) Reset 

func (x *RewardRequest) Reset()

func (*RewardRequest) String 

func (x *RewardRequest) String() string

type RewardRequest_Coinbase 

type RewardRequest_Coinbase struct {
	Coinbase string `protobuf:"bytes,3,opt,name=coinbase,proto3,oneof"` // filter by coinbase
}

type RewardRequest_Smesher 

type RewardRequest_Smesher struct {
	Smesher []byte `protobuf:"bytes,4,opt,name=smesher,proto3,oneof"` // filter by smesher
}

type RewardServiceClient 

type RewardServiceClient interface {
	// List of rewards
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of rewards based on the provided request parameters.
	List(ctx context.Context, in *RewardRequest, opts ...grpc.CallOption) (*RewardList, error)
}

RewardServiceClient is the client API for RewardService 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.

func NewRewardServiceClient 

func NewRewardServiceClient(cc grpc.ClientConnInterface) RewardServiceClient

type RewardServiceServer 

type RewardServiceServer interface {
	// List of rewards
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of rewards based on the provided request parameters.
	List(context.Context, *RewardRequest) (*RewardList, error)
}

RewardServiceServer is the server API for RewardService service. All implementations should embed UnimplementedRewardServiceServer for forward compatibility

type RewardStreamRequest 

type RewardStreamRequest struct {
	StartLayer uint32 `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"`
	EndLayer   uint32 `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3" json:"end_layer,omitempty"`
	// Types that are assignable to FilterBy:
	//
	//	*RewardStreamRequest_Coinbase
	//	*RewardStreamRequest_Smesher
	FilterBy isRewardStreamRequest_FilterBy `protobuf_oneof:"filter_by"`
	Watch    bool                           `protobuf:"varint,5,opt,name=watch,proto3" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

func (*RewardStreamRequest) Descriptor deprecated 

func (*RewardStreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use RewardStreamRequest.ProtoReflect.Descriptor instead.

func (*RewardStreamRequest) GetCoinbase 

func (x *RewardStreamRequest) GetCoinbase() string

func (*RewardStreamRequest) GetEndLayer 

func (x *RewardStreamRequest) GetEndLayer() uint32

func (*RewardStreamRequest) GetFilterBy 

func (m *RewardStreamRequest) GetFilterBy() isRewardStreamRequest_FilterBy

func (*RewardStreamRequest) GetSmesher 

func (x *RewardStreamRequest) GetSmesher() []byte

func (*RewardStreamRequest) GetStartLayer 

func (x *RewardStreamRequest) GetStartLayer() uint32

func (*RewardStreamRequest) GetWatch 

func (x *RewardStreamRequest) GetWatch() bool

func (*RewardStreamRequest) ProtoMessage 

func (*RewardStreamRequest) ProtoMessage()

func (*RewardStreamRequest) ProtoReflect 

func (x *RewardStreamRequest) ProtoReflect() protoreflect.Message

func (*RewardStreamRequest) Reset 

func (x *RewardStreamRequest) Reset()

func (*RewardStreamRequest) String 

func (x *RewardStreamRequest) String() string

type RewardStreamRequest_Coinbase 

type RewardStreamRequest_Coinbase struct {
	Coinbase string `protobuf:"bytes,3,opt,name=coinbase,proto3,oneof"`
}

type RewardStreamRequest_Smesher 

type RewardStreamRequest_Smesher struct {
	Smesher []byte `protobuf:"bytes,4,opt,name=smesher,proto3,oneof"`
}

type RewardStreamServiceClient 

type RewardStreamServiceClient interface {
	Stream(ctx context.Context, in *RewardStreamRequest, opts ...grpc.CallOption) (RewardStreamService_StreamClient, error)
}

RewardStreamServiceClient is the client API for RewardStreamService 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.

func NewRewardStreamServiceClient 

func NewRewardStreamServiceClient(cc grpc.ClientConnInterface) RewardStreamServiceClient

type RewardStreamServiceServer 

type RewardStreamServiceServer interface {
	Stream(*RewardStreamRequest, RewardStreamService_StreamServer) error
}

RewardStreamServiceServer is the server API for RewardStreamService service. All implementations should embed UnimplementedRewardStreamServiceServer for forward compatibility

type RewardStreamService_StreamClient 

type RewardStreamService_StreamClient interface {
	Recv() (*Reward, error)
	grpc.ClientStream
}

type RewardStreamService_StreamServer 

type RewardStreamService_StreamServer interface {
	Send(*Reward) error
	grpc.ServerStream
}

type SortOrder 

type SortOrder int32
const (
	SortOrder_ASC  SortOrder = 0
	SortOrder_DESC SortOrder = 1
)

func (SortOrder) Descriptor 

func (SortOrder) Descriptor() protoreflect.EnumDescriptor

func (SortOrder) Enum 

func (x SortOrder) Enum() *SortOrder

func (SortOrder) EnumDescriptor deprecated 

func (SortOrder) EnumDescriptor() ([]byte, []int)

Deprecated: Use SortOrder.Descriptor instead.

func (SortOrder) Number 

func (x SortOrder) Number() protoreflect.EnumNumber

func (SortOrder) String 

func (x SortOrder) String() string

func (SortOrder) Type 

func (SortOrder) Type() protoreflect.EnumType

type SubmitTransactionRequest 

type SubmitTransactionRequest struct {
	Transaction []byte `protobuf:"bytes,1,opt,name=transaction,proto3" json:"transaction,omitempty"` // signed binary transaction
	// contains filtered or unexported fields
}

func (*SubmitTransactionRequest) Descriptor deprecated 

func (*SubmitTransactionRequest) Descriptor() ([]byte, []int)

Deprecated: Use SubmitTransactionRequest.ProtoReflect.Descriptor instead.

func (*SubmitTransactionRequest) GetTransaction 

func (x *SubmitTransactionRequest) GetTransaction() []byte

func (*SubmitTransactionRequest) ProtoMessage 

func (*SubmitTransactionRequest) ProtoMessage()

func (*SubmitTransactionRequest) ProtoReflect 

func (x *SubmitTransactionRequest) ProtoReflect() protoreflect.Message

func (*SubmitTransactionRequest) Reset 

func (x *SubmitTransactionRequest) Reset()

func (*SubmitTransactionRequest) String 

func (x *SubmitTransactionRequest) String() string

type SubmitTransactionResponse 

type SubmitTransactionResponse struct {
	Status *status.Status `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
	TxId   []byte         `protobuf:"bytes,2,opt,name=tx_id,json=txId,proto3" json:"tx_id,omitempty"` // transaction ID
	// contains filtered or unexported fields
}

func (*SubmitTransactionResponse) Descriptor deprecated 

func (*SubmitTransactionResponse) Descriptor() ([]byte, []int)

Deprecated: Use SubmitTransactionResponse.ProtoReflect.Descriptor instead.

func (*SubmitTransactionResponse) GetStatus 

func (x *SubmitTransactionResponse) GetStatus() *status.Status

func (*SubmitTransactionResponse) GetTxId 

func (x *SubmitTransactionResponse) GetTxId() []byte

func (*SubmitTransactionResponse) ProtoMessage 

func (*SubmitTransactionResponse) ProtoMessage()

func (*SubmitTransactionResponse) ProtoReflect 

func (x *SubmitTransactionResponse) ProtoReflect() protoreflect.Message

func (*SubmitTransactionResponse) Reset 

func (x *SubmitTransactionResponse) Reset()

func (*SubmitTransactionResponse) String 

func (x *SubmitTransactionResponse) String() string

type Transaction 

type Transaction struct {
	Id        []byte                      `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Principal string                      `protobuf:"bytes,2,opt,name=principal,proto3" json:"principal,omitempty"` // principal account address
	Template  string                      `protobuf:"bytes,3,opt,name=template,proto3" json:"template,omitempty"`   // template account address
	Method    uint32                      `protobuf:"varint,4,opt,name=method,proto3" json:"method,omitempty"`      // this is actually limited by uint8, but no type for that.
	Nonce     *Nonce                      `protobuf:"bytes,5,opt,name=nonce,proto3" json:"nonce,omitempty"`
	MaxGas    uint64                      `protobuf:"varint,6,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"`       // max gas units consumed by tx
	GasPrice  uint64                      `protobuf:"varint,7,opt,name=gas_price,json=gasPrice,proto3" json:"gas_price,omitempty"` // fee per unit gas, in smidge
	MaxSpend  uint64                      `protobuf:"varint,8,opt,name=max_spend,json=maxSpend,proto3" json:"max_spend,omitempty"`
	Raw       []byte                      `protobuf:"bytes,9,opt,name=raw,proto3" json:"raw,omitempty"`
	Type      Transaction_TransactionType `protobuf:"varint,10,opt,name=type,proto3,enum=spacemesh.v2beta1.Transaction_TransactionType" json:"type,omitempty"`
	Contents  *TransactionContents        `protobuf:"bytes,11,opt,name=contents,proto3" json:"contents,omitempty"` // parsed transaction contents
	// contains filtered or unexported fields
}

An immutable Spacemesh transaction. do not include mutable data such as tx state or result.

func (*Transaction) Descriptor deprecated 

func (*Transaction) Descriptor() ([]byte, []int)

Deprecated: Use Transaction.ProtoReflect.Descriptor instead.

func (*Transaction) GetContents 

func (x *Transaction) GetContents() *TransactionContents

func (*Transaction) GetGasPrice 

func (x *Transaction) GetGasPrice() uint64

func (*Transaction) GetId 

func (x *Transaction) GetId() []byte

func (*Transaction) GetMaxGas 

func (x *Transaction) GetMaxGas() uint64

func (*Transaction) GetMaxSpend 

func (x *Transaction) GetMaxSpend() uint64

func (*Transaction) GetMethod 

func (x *Transaction) GetMethod() uint32

func (*Transaction) GetNonce 

func (x *Transaction) GetNonce() *Nonce

func (*Transaction) GetPrincipal 

func (x *Transaction) GetPrincipal() string

func (*Transaction) GetRaw 

func (x *Transaction) GetRaw() []byte

func (*Transaction) GetTemplate 

func (x *Transaction) GetTemplate() string

func (*Transaction) GetType 

func (x *Transaction) GetType() Transaction_TransactionType

func (*Transaction) ProtoMessage 

func (*Transaction) ProtoMessage()

func (*Transaction) ProtoReflect 

func (x *Transaction) ProtoReflect() protoreflect.Message

func (*Transaction) Reset 

func (x *Transaction) Reset()

func (*Transaction) String 

func (x *Transaction) String() string

type TransactionContents 

type TransactionContents struct {

	// Types that are assignable to Contents:
	//
	//	*TransactionContents_Send
	//	*TransactionContents_SingleSigSpawn
	//	*TransactionContents_MultiSigSpawn
	//	*TransactionContents_VestingSpawn
	//	*TransactionContents_VaultSpawn
	//	*TransactionContents_DrainVault
	Contents isTransactionContents_Contents `protobuf_oneof:"contents"`
	// contains filtered or unexported fields
}

func (*TransactionContents) Descriptor deprecated 

func (*TransactionContents) Descriptor() ([]byte, []int)

Deprecated: Use TransactionContents.ProtoReflect.Descriptor instead.

func (*TransactionContents) GetContents 

func (m *TransactionContents) GetContents() isTransactionContents_Contents

func (*TransactionContents) GetDrainVault 

func (x *TransactionContents) GetDrainVault() *ContentsDrainVault

func (*TransactionContents) GetMultiSigSpawn 

func (x *TransactionContents) GetMultiSigSpawn() *ContentsMultiSigSpawn

func (*TransactionContents) GetSend 

func (x *TransactionContents) GetSend() *ContentsSend

func (*TransactionContents) GetSingleSigSpawn 

func (x *TransactionContents) GetSingleSigSpawn() *ContentsSingleSigSpawn

func (*TransactionContents) GetVaultSpawn 

func (x *TransactionContents) GetVaultSpawn() *ContentsVaultSpawn

func (*TransactionContents) GetVestingSpawn 

func (x *TransactionContents) GetVestingSpawn() *ContentsMultiSigSpawn

func (*TransactionContents) ProtoMessage 

func (*TransactionContents) ProtoMessage()

func (*TransactionContents) ProtoReflect 

func (x *TransactionContents) ProtoReflect() protoreflect.Message

func (*TransactionContents) Reset 

func (x *TransactionContents) Reset()

func (*TransactionContents) String 

func (x *TransactionContents) String() string

type TransactionContents_DrainVault 

type TransactionContents_DrainVault struct {
	DrainVault *ContentsDrainVault `protobuf:"bytes,6,opt,name=drain_vault,json=drainVault,proto3,oneof"`
}

type TransactionContents_MultiSigSpawn 

type TransactionContents_MultiSigSpawn struct {
	MultiSigSpawn *ContentsMultiSigSpawn `protobuf:"bytes,3,opt,name=multi_sig_spawn,json=multiSigSpawn,proto3,oneof"`
}

type TransactionContents_Send 

type TransactionContents_Send struct {
	Send *ContentsSend `protobuf:"bytes,1,opt,name=send,proto3,oneof"`
}

type TransactionContents_SingleSigSpawn 

type TransactionContents_SingleSigSpawn struct {
	SingleSigSpawn *ContentsSingleSigSpawn `protobuf:"bytes,2,opt,name=single_sig_spawn,json=singleSigSpawn,proto3,oneof"`
}

type TransactionContents_VaultSpawn 

type TransactionContents_VaultSpawn struct {
	VaultSpawn *ContentsVaultSpawn `protobuf:"bytes,5,opt,name=vault_spawn,json=vaultSpawn,proto3,oneof"`
}

type TransactionContents_VestingSpawn 

type TransactionContents_VestingSpawn struct {
	VestingSpawn *ContentsMultiSigSpawn `protobuf:"bytes,4,opt,name=vesting_spawn,json=vestingSpawn,proto3,oneof"`
}

type TransactionList 

type TransactionList struct {
	Transactions []*TransactionResponse `protobuf:"bytes,1,rep,name=transactions,proto3" json:"transactions,omitempty"` // list of transactions
	// contains filtered or unexported fields
}

func (*TransactionList) Descriptor deprecated 

func (*TransactionList) Descriptor() ([]byte, []int)

Deprecated: Use TransactionList.ProtoReflect.Descriptor instead.

func (*TransactionList) GetTransactions 

func (x *TransactionList) GetTransactions() []*TransactionResponse

func (*TransactionList) ProtoMessage 

func (*TransactionList) ProtoMessage()

func (*TransactionList) ProtoReflect 

func (x *TransactionList) ProtoReflect() protoreflect.Message

func (*TransactionList) Reset 

func (x *TransactionList) Reset()

func (*TransactionList) String 

func (x *TransactionList) String() string

type TransactionRequest 

type TransactionRequest struct {
	StartLayer    *uint32   `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3,oneof" json:"start_layer,omitempty"`                          // Starting layer for transactions.
	EndLayer      *uint32   `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3,oneof" json:"end_layer,omitempty"`                                // Ending layer for transactions.
	Txid          [][]byte  `protobuf:"bytes,3,rep,name=txid,proto3" json:"txid,omitempty"`                                                               // Filter: specific transaction IDs to filter.
	Address       *string   `protobuf:"bytes,4,opt,name=address,proto3,oneof" json:"address,omitempty"`                                                   // Filter by address (principal or recipient)
	Offset        uint64    `protobuf:"varint,6,opt,name=offset,proto3" json:"offset,omitempty"`                                                          // Adjusts the starting point for data retrieval.
	Limit         uint64    `protobuf:"varint,7,opt,name=limit,proto3" json:"limit,omitempty"`                                                            // Specifies maximum number of items to fetch.
	IncludeState  bool      `protobuf:"varint,8,opt,name=include_state,json=includeState,proto3" json:"include_state,omitempty"`                          // Whether to include transaction state in response.
	IncludeResult bool      `protobuf:"varint,9,opt,name=include_result,json=includeResult,proto3" json:"include_result,omitempty"`                       // Whether to include result of transactions in response.
	SortOrder     SortOrder `protobuf:"varint,10,opt,name=sort_order,json=sortOrder,proto3,enum=spacemesh.v2beta1.SortOrder" json:"sort_order,omitempty"` // specifies the sort order by layer (default is ASC)
	// contains filtered or unexported fields
}

func (*TransactionRequest) Descriptor deprecated 

func (*TransactionRequest) Descriptor() ([]byte, []int)

Deprecated: Use TransactionRequest.ProtoReflect.Descriptor instead.

func (*TransactionRequest) GetAddress 

func (x *TransactionRequest) GetAddress() string

func (*TransactionRequest) GetEndLayer 

func (x *TransactionRequest) GetEndLayer() uint32

func (*TransactionRequest) GetIncludeResult 

func (x *TransactionRequest) GetIncludeResult() bool

func (*TransactionRequest) GetIncludeState 

func (x *TransactionRequest) GetIncludeState() bool

func (*TransactionRequest) GetLimit 

func (x *TransactionRequest) GetLimit() uint64

func (*TransactionRequest) GetOffset 

func (x *TransactionRequest) GetOffset() uint64

func (*TransactionRequest) GetSortOrder 

func (x *TransactionRequest) GetSortOrder() SortOrder

func (*TransactionRequest) GetStartLayer 

func (x *TransactionRequest) GetStartLayer() uint32

func (*TransactionRequest) GetTxid 

func (x *TransactionRequest) GetTxid() [][]byte

func (*TransactionRequest) ProtoMessage 

func (*TransactionRequest) ProtoMessage()

func (*TransactionRequest) ProtoReflect 

func (x *TransactionRequest) ProtoReflect() protoreflect.Message

func (*TransactionRequest) Reset 

func (x *TransactionRequest) Reset()

func (*TransactionRequest) String 

func (x *TransactionRequest) String() string

type TransactionResponse 

type TransactionResponse struct {
	Tx       *Transaction       `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`                             // transaction
	TxResult *TransactionResult `protobuf:"bytes,2,opt,name=tx_result,json=txResult,proto3" json:"tx_result,omitempty"` // optional transaction result
	TxState  *TransactionState  ``                                                                                      // optional transaction state
	/* 129-byte string literal not displayed */
	// contains filtered or unexported fields
}

func (*TransactionResponse) Descriptor deprecated 

func (*TransactionResponse) Descriptor() ([]byte, []int)

Deprecated: Use TransactionResponse.ProtoReflect.Descriptor instead.

func (*TransactionResponse) GetTx 

func (x *TransactionResponse) GetTx() *Transaction

func (*TransactionResponse) GetTxResult 

func (x *TransactionResponse) GetTxResult() *TransactionResult

func (*TransactionResponse) GetTxState 

func (x *TransactionResponse) GetTxState() TransactionState

func (*TransactionResponse) ProtoMessage 

func (*TransactionResponse) ProtoMessage()

func (*TransactionResponse) ProtoReflect 

func (x *TransactionResponse) ProtoReflect() protoreflect.Message

func (*TransactionResponse) Reset 

func (x *TransactionResponse) Reset()

func (*TransactionResponse) String 

func (x *TransactionResponse) String() string

type TransactionResult 

type TransactionResult struct {
	Status           TransactionResult_Status `protobuf:"varint,1,opt,name=status,proto3,enum=spacemesh.v2beta1.TransactionResult_Status" json:"status,omitempty"` // status of the transaction
	Message          string                   `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	GasConsumed      uint64                   `protobuf:"varint,3,opt,name=gas_consumed,json=gasConsumed,proto3" json:"gas_consumed,omitempty"`               // in units of gas
	Fee              uint64                   `protobuf:"varint,4,opt,name=fee,proto3" json:"fee,omitempty"`                                                  // in smidge
	Block            []byte                   `protobuf:"bytes,5,opt,name=block,proto3" json:"block,omitempty"`                                               // block hash
	Layer            uint32                   `protobuf:"varint,6,opt,name=layer,proto3" json:"layer,omitempty"`                                              // layer number
	TouchedAddresses []string                 `protobuf:"bytes,7,rep,name=touched_addresses,json=touchedAddresses,proto3" json:"touched_addresses,omitempty"` // addresses touched by the tx
	// contains filtered or unexported fields
}

func (*TransactionResult) Descriptor deprecated 

func (*TransactionResult) Descriptor() ([]byte, []int)

Deprecated: Use TransactionResult.ProtoReflect.Descriptor instead.

func (*TransactionResult) GetBlock 

func (x *TransactionResult) GetBlock() []byte

func (*TransactionResult) GetFee 

func (x *TransactionResult) GetFee() uint64

func (*TransactionResult) GetGasConsumed 

func (x *TransactionResult) GetGasConsumed() uint64

func (*TransactionResult) GetLayer 

func (x *TransactionResult) GetLayer() uint32

func (*TransactionResult) GetMessage 

func (x *TransactionResult) GetMessage() string

func (*TransactionResult) GetStatus 

func (x *TransactionResult) GetStatus() TransactionResult_Status

func (*TransactionResult) GetTouchedAddresses 

func (x *TransactionResult) GetTouchedAddresses() []string

func (*TransactionResult) ProtoMessage 

func (*TransactionResult) ProtoMessage()

func (*TransactionResult) ProtoReflect 

func (x *TransactionResult) ProtoReflect() protoreflect.Message

func (*TransactionResult) Reset 

func (x *TransactionResult) Reset()

func (*TransactionResult) String 

func (x *TransactionResult) String() string

type TransactionResult_Status 

type TransactionResult_Status int32
const (
	TransactionResult_TRANSACTION_STATUS_UNSPECIFIED TransactionResult_Status = 0
	TransactionResult_TRANSACTION_STATUS_SUCCESS     TransactionResult_Status = 1
	TransactionResult_TRANSACTION_STATUS_FAILURE     TransactionResult_Status = 2
	TransactionResult_TRANSACTION_STATUS_INVALID     TransactionResult_Status = 3
)

func (TransactionResult_Status) Descriptor 

func (TransactionResult_Status) Descriptor() protoreflect.EnumDescriptor

func (TransactionResult_Status) Enum 

func (x TransactionResult_Status) Enum() *TransactionResult_Status

func (TransactionResult_Status) EnumDescriptor deprecated 

func (TransactionResult_Status) EnumDescriptor() ([]byte, []int)

Deprecated: Use TransactionResult_Status.Descriptor instead.

func (TransactionResult_Status) Number 

func (x TransactionResult_Status) Number() protoreflect.EnumNumber

func (TransactionResult_Status) String 

func (x TransactionResult_Status) String() string

func (TransactionResult_Status) Type 

func (TransactionResult_Status) Type() protoreflect.EnumType

type TransactionServiceClient 

type TransactionServiceClient interface {
	// List of transactions
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of transactions based on the provided request parameters.
	List(ctx context.Context, in *TransactionRequest, opts ...grpc.CallOption) (*TransactionList, error)
	// Parse transaction
	//
	// ParseTransaction is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to parse a signed binary transaction and optionally verify its signature.
	ParseTransaction(ctx context.Context, in *ParseTransactionRequest, opts ...grpc.CallOption) (*ParseTransactionResponse, error)
	// Submit transaction
	//
	// SubmitTransaction is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to submit a signed binary transaction to the network.
	SubmitTransaction(ctx context.Context, in *SubmitTransactionRequest, opts ...grpc.CallOption) (*SubmitTransactionResponse, error)
	// Estimate gas for transaction
	//
	// EstimateGas is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to estimate the recommended maximum gas for a signed binary transaction.
	EstimateGas(ctx context.Context, in *EstimateGasRequest, opts ...grpc.CallOption) (*EstimateGasResponse, error)
}

TransactionServiceClient is the client API for TransactionService 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.

func NewTransactionServiceClient 

func NewTransactionServiceClient(cc grpc.ClientConnInterface) TransactionServiceClient

type TransactionServiceServer 

type TransactionServiceServer interface {
	// List of transactions
	//
	// List is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to retrieve a list of transactions based on the provided request parameters.
	List(context.Context, *TransactionRequest) (*TransactionList, error)
	// Parse transaction
	//
	// ParseTransaction is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to parse a signed binary transaction and optionally verify its signature.
	ParseTransaction(context.Context, *ParseTransactionRequest) (*ParseTransactionResponse, error)
	// Submit transaction
	//
	// SubmitTransaction is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to submit a signed binary transaction to the network.
	SubmitTransaction(context.Context, *SubmitTransactionRequest) (*SubmitTransactionResponse, error)
	// Estimate gas for transaction
	//
	// EstimateGas is a method that takes a "{{.RequestType.Name}}" body and returns an "{{.ResponseType.Name}}".
	// This method is used to estimate the recommended maximum gas for a signed binary transaction.
	EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)
}

TransactionServiceServer is the server API for TransactionService service. All implementations should embed UnimplementedTransactionServiceServer for forward compatibility

type TransactionState 

type TransactionState int32

TransactionState is the "journey" of a tx from mempool to block inclusion to mesh to STF processing. To know whether or not the tx actually succeeded, and its side effects, check tx_state. 

const (
	TransactionState_TRANSACTION_STATE_UNSPECIFIED        TransactionState = 0 // default state
	TransactionState_TRANSACTION_STATE_REJECTED           TransactionState = 1 // rejected from mempool due to, e.g., invalid syntax
	TransactionState_TRANSACTION_STATE_INSUFFICIENT_FUNDS TransactionState = 2 // rejected from mempool by funds check
	TransactionState_TRANSACTION_STATE_CONFLICTING        TransactionState = 3 // rejected from mempool due to conflicting counter
	TransactionState_TRANSACTION_STATE_MEMPOOL            TransactionState = 4 // in mempool but not on the mesh yet
	TransactionState_TRANSACTION_STATE_MESH               TransactionState = 5 // submitted to the mesh
	TransactionState_TRANSACTION_STATE_PROCESSED          TransactionState = 6 // processed by STF; check Receipt for success or failure
	TransactionState_TRANSACTION_STATE_INEFFECTUAL        TransactionState = 7 // removed from mempool and will be forgotten and never executed
)

func (TransactionState) Descriptor 

func (TransactionState) Descriptor() protoreflect.EnumDescriptor

func (TransactionState) Enum 

func (x TransactionState) Enum() *TransactionState

func (TransactionState) EnumDescriptor deprecated 

func (TransactionState) EnumDescriptor() ([]byte, []int)

Deprecated: Use TransactionState.Descriptor instead.

func (TransactionState) Number 

func (x TransactionState) Number() protoreflect.EnumNumber

func (TransactionState) String 

func (x TransactionState) String() string

func (TransactionState) Type 

func (TransactionState) Type() protoreflect.EnumType

type TransactionStreamRequest 

type TransactionStreamRequest struct {
	StartLayer uint32   `protobuf:"varint,1,opt,name=start_layer,json=startLayer,proto3" json:"start_layer,omitempty"` // Required: starting layer for transaction streaming.
	EndLayer   *uint32  `protobuf:"varint,2,opt,name=end_layer,json=endLayer,proto3,oneof" json:"end_layer,omitempty"` // Ending layer for transaction streaming.
	Txid       [][]byte `protobuf:"bytes,3,rep,name=txid,proto3" json:"txid,omitempty"`                                // Filter: specific transaction IDs.
	Principal  *string  `protobuf:"bytes,4,opt,name=principal,proto3,oneof" json:"principal,omitempty"`                // Filter by principal address
	Watch      bool     `protobuf:"varint,5,opt,name=watch,proto3" json:"watch,omitempty"`                             // Continue watching for new transactions.
	// contains filtered or unexported fields
}

func (*TransactionStreamRequest) Descriptor deprecated 

func (*TransactionStreamRequest) Descriptor() ([]byte, []int)

Deprecated: Use TransactionStreamRequest.ProtoReflect.Descriptor instead.

func (*TransactionStreamRequest) GetEndLayer 

func (x *TransactionStreamRequest) GetEndLayer() uint32

func (*TransactionStreamRequest) GetPrincipal 

func (x *TransactionStreamRequest) GetPrincipal() string

func (*TransactionStreamRequest) GetStartLayer 

func (x *TransactionStreamRequest) GetStartLayer() uint32

func (*TransactionStreamRequest) GetTxid 

func (x *TransactionStreamRequest) GetTxid() [][]byte

func (*TransactionStreamRequest) GetWatch 

func (x *TransactionStreamRequest) GetWatch() bool

func (*TransactionStreamRequest) ProtoMessage 

func (*TransactionStreamRequest) ProtoMessage()

func (*TransactionStreamRequest) ProtoReflect 

func (x *TransactionStreamRequest) ProtoReflect() protoreflect.Message

func (*TransactionStreamRequest) Reset 

func (x *TransactionStreamRequest) Reset()

func (*TransactionStreamRequest) String 

func (x *TransactionStreamRequest) String() string

type TransactionStreamServiceClient 

type TransactionStreamServiceClient interface {
	Stream(ctx context.Context, in *TransactionStreamRequest, opts ...grpc.CallOption) (TransactionStreamService_StreamClient, error)
}

TransactionStreamServiceClient is the client API for TransactionStreamService 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.

func NewTransactionStreamServiceClient 

func NewTransactionStreamServiceClient(cc grpc.ClientConnInterface) TransactionStreamServiceClient

type TransactionStreamServiceServer 

type TransactionStreamServiceServer interface {
	Stream(*TransactionStreamRequest, TransactionStreamService_StreamServer) error
}

TransactionStreamServiceServer is the server API for TransactionStreamService service. All implementations should embed UnimplementedTransactionStreamServiceServer for forward compatibility

type TransactionStreamService_StreamClient 

type TransactionStreamService_StreamClient interface {
	Recv() (*TransactionResponse, error)
	grpc.ClientStream
}

type TransactionStreamService_StreamServer 

type TransactionStreamService_StreamServer interface {
	Send(*TransactionResponse) error
	grpc.ServerStream
}

type Transaction_TransactionType 

type Transaction_TransactionType int32
const (
	Transaction_TRANSACTION_TYPE_UNSPECIFIED      Transaction_TransactionType = 0
	Transaction_TRANSACTION_TYPE_SINGLE_SIG_SEND  Transaction_TransactionType = 1
	Transaction_TRANSACTION_TYPE_SINGLE_SIG_SPAWN Transaction_TransactionType = 2
	// Deprecated: Marked as deprecated in spacemesh/v2beta1/tx.proto.
	Transaction_TRANSACTION_TYPE_SINGLE_SIG_SELFSPAWN Transaction_TransactionType = 3
	Transaction_TRANSACTION_TYPE_MULTI_SIG_SEND       Transaction_TransactionType = 4
	Transaction_TRANSACTION_TYPE_MULTI_SIG_SPAWN      Transaction_TransactionType = 5
	// Deprecated: Marked as deprecated in spacemesh/v2beta1/tx.proto.
	Transaction_TRANSACTION_TYPE_MULTI_SIG_SELFSPAWN Transaction_TransactionType = 6
	Transaction_TRANSACTION_TYPE_VESTING_SPAWN       Transaction_TransactionType = 7
	Transaction_TRANSACTION_TYPE_VAULT_SPAWN         Transaction_TransactionType = 8
	Transaction_TRANSACTION_TYPE_DRAIN_VAULT         Transaction_TransactionType = 9
)

func (Transaction_TransactionType) Descriptor 

func (Transaction_TransactionType) Descriptor() protoreflect.EnumDescriptor

func (Transaction_TransactionType) Enum 

func (x Transaction_TransactionType) Enum() *Transaction_TransactionType

func (Transaction_TransactionType) EnumDescriptor deprecated 

func (Transaction_TransactionType) EnumDescriptor() ([]byte, []int)

Deprecated: Use Transaction_TransactionType.Descriptor instead.

func (Transaction_TransactionType) Number 

func (x Transaction_TransactionType) Number() protoreflect.EnumNumber

func (Transaction_TransactionType) String 

func (x Transaction_TransactionType) String() string

func (Transaction_TransactionType) Type 

func (Transaction_TransactionType) Type() protoreflect.EnumType

type UnimplementedAccountServiceServer 

type UnimplementedAccountServiceServer struct {
}

UnimplementedAccountServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedAccountServiceServer) List 

func (UnimplementedAccountServiceServer) List(context.Context, *AccountRequest) (*AccountList, error)

type UnimplementedActivationServiceServer 

type UnimplementedActivationServiceServer struct {
}

UnimplementedActivationServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedActivationServiceServer) ActivationsCount 

func (UnimplementedActivationServiceServer) ActivationsCount(context.Context, *ActivationsCountRequest) (*ActivationsCountResponse, error)

func (UnimplementedActivationServiceServer) Highest 

func (UnimplementedActivationServiceServer) Highest(context.Context, *HighestRequest) (*HighestResponse, error)

func (UnimplementedActivationServiceServer) List 

func (UnimplementedActivationServiceServer) List(context.Context, *ActivationRequest) (*ActivationList, error)

type UnimplementedActivationStreamServiceServer 

type UnimplementedActivationStreamServiceServer struct {
}

UnimplementedActivationStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedActivationStreamServiceServer) Stream 

func (UnimplementedActivationStreamServiceServer) Stream(*ActivationStreamRequest, ActivationStreamService_StreamServer) error

type UnimplementedLayerServiceServer 

type UnimplementedLayerServiceServer struct {
}

UnimplementedLayerServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedLayerServiceServer) List 

func (UnimplementedLayerServiceServer) List(context.Context, *LayerRequest) (*LayerList, error)

type UnimplementedLayerStreamServiceServer 

type UnimplementedLayerStreamServiceServer struct {
}

UnimplementedLayerStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedLayerStreamServiceServer) Stream 

func (UnimplementedLayerStreamServiceServer) Stream(*LayerStreamRequest, LayerStreamService_StreamServer) error

type UnimplementedMalfeasanceServiceServer 

type UnimplementedMalfeasanceServiceServer struct {
}

UnimplementedMalfeasanceServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedMalfeasanceServiceServer) List 

func (UnimplementedMalfeasanceServiceServer) List(context.Context, *MalfeasanceRequest) (*MalfeasanceList, error)

type UnimplementedMalfeasanceStreamServiceServer 

type UnimplementedMalfeasanceStreamServiceServer struct {
}

UnimplementedMalfeasanceStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedMalfeasanceStreamServiceServer) Stream 

func (UnimplementedMalfeasanceStreamServiceServer) Stream(*MalfeasanceStreamRequest, MalfeasanceStreamService_StreamServer) error

type UnimplementedNetworkServiceServer 

type UnimplementedNetworkServiceServer struct {
}

UnimplementedNetworkServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedNetworkServiceServer) Info 

func (UnimplementedNetworkServiceServer) Info(context.Context, *NetworkInfoRequest) (*NetworkInfoResponse, error)

type UnimplementedNodeServiceServer 

type UnimplementedNodeServiceServer struct {
}

UnimplementedNodeServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedNodeServiceServer) Status 

func (UnimplementedNodeServiceServer) Status(context.Context, *NodeStatusRequest) (*NodeStatusResponse, error)

type UnimplementedRewardServiceServer 

type UnimplementedRewardServiceServer struct {
}

UnimplementedRewardServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedRewardServiceServer) List 

func (UnimplementedRewardServiceServer) List(context.Context, *RewardRequest) (*RewardList, error)

type UnimplementedRewardStreamServiceServer 

type UnimplementedRewardStreamServiceServer struct {
}

UnimplementedRewardStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedRewardStreamServiceServer) Stream 

func (UnimplementedRewardStreamServiceServer) Stream(*RewardStreamRequest, RewardStreamService_StreamServer) error

type UnimplementedTransactionServiceServer 

type UnimplementedTransactionServiceServer struct {
}

UnimplementedTransactionServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedTransactionServiceServer) EstimateGas 

func (UnimplementedTransactionServiceServer) EstimateGas(context.Context, *EstimateGasRequest) (*EstimateGasResponse, error)

func (UnimplementedTransactionServiceServer) List 

func (UnimplementedTransactionServiceServer) List(context.Context, *TransactionRequest) (*TransactionList, error)

func (UnimplementedTransactionServiceServer) ParseTransaction 

func (UnimplementedTransactionServiceServer) ParseTransaction(context.Context, *ParseTransactionRequest) (*ParseTransactionResponse, error)

func (UnimplementedTransactionServiceServer) SubmitTransaction 

func (UnimplementedTransactionServiceServer) SubmitTransaction(context.Context, *SubmitTransactionRequest) (*SubmitTransactionResponse, error)

type UnimplementedTransactionStreamServiceServer 

type UnimplementedTransactionStreamServiceServer struct {
}

UnimplementedTransactionStreamServiceServer should be embedded to have forward compatible implementations.

func (UnimplementedTransactionStreamServiceServer) Stream 

func (UnimplementedTransactionStreamServiceServer) Stream(*TransactionStreamRequest, TransactionStreamService_StreamServer) error

type UnsafeAccountServiceServer 

type UnsafeAccountServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeAccountServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to AccountServiceServer will result in compilation errors.

type UnsafeActivationServiceServer 

type UnsafeActivationServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeActivationServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ActivationServiceServer will result in compilation errors.

type UnsafeActivationStreamServiceServer 

type UnsafeActivationStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeActivationStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to ActivationStreamServiceServer will result in compilation errors.

type UnsafeLayerServiceServer 

type UnsafeLayerServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeLayerServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to LayerServiceServer will result in compilation errors.

type UnsafeLayerStreamServiceServer 

type UnsafeLayerStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeLayerStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to LayerStreamServiceServer will result in compilation errors.

type UnsafeMalfeasanceServiceServer 

type UnsafeMalfeasanceServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMalfeasanceServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MalfeasanceServiceServer will result in compilation errors.

type UnsafeMalfeasanceStreamServiceServer 

type UnsafeMalfeasanceStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeMalfeasanceStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to MalfeasanceStreamServiceServer will result in compilation errors.

type UnsafeNetworkServiceServer 

type UnsafeNetworkServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNetworkServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NetworkServiceServer will result in compilation errors.

type UnsafeNodeServiceServer 

type UnsafeNodeServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeNodeServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to NodeServiceServer will result in compilation errors.

type UnsafeRewardServiceServer 

type UnsafeRewardServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeRewardServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to RewardServiceServer will result in compilation errors.

type UnsafeRewardStreamServiceServer 

type UnsafeRewardStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeRewardStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to RewardStreamServiceServer will result in compilation errors.

type UnsafeTransactionServiceServer 

type UnsafeTransactionServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeTransactionServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to TransactionServiceServer will result in compilation errors.

type UnsafeTransactionStreamServiceServer 

type UnsafeTransactionStreamServiceServer interface {
	// contains filtered or unexported methods
}

UnsafeTransactionStreamServiceServer may be embedded to opt out of forward compatibility for this service. Use of this interface is not recommended, as added methods to TransactionStreamServiceServer will result in compilation errors.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.