From b1e0b0159848bbc0038ba05e714b8f20c6008b7e3d461dd62f19af8fadd3353e Mon Sep 17 00:00:00 2001 From: nfel Date: Fri, 14 Aug 2026 18:52:30 +0330 Subject: [PATCH] feat(gl): scaffold general ledger grpc service --- Makefile | 10 + README.md | 10 + application/health/service.go | 29 + application/health/service_test.go | 30 + buf.gen.yaml | 16 + cmd/gl/main.go | 40 + gen/base/v1/msg.pb.go | 368 ++++++ gen/ledger/v1/msg.pb.go | 1767 ++++++++++++++++++++++++++ gen/ledger/v1/srv.pb.go | 102 ++ gen/ledger/v1/srv_grpc.pb.go | 348 +++++ gl.cfg.toml | 14 + go.mod | 24 + go.sum | 40 + infrastructure/config/config.go | 81 ++ infrastructure/config/config_test.go | 46 + interface/grpc/health.go | 26 + interface/grpc/health_test.go | 19 + interface/grpc/server.go | 69 + interface/grpc/server_test.go | 26 + 19 files changed, 3065 insertions(+) create mode 100644 Makefile create mode 100644 application/health/service.go create mode 100644 application/health/service_test.go create mode 100644 buf.gen.yaml create mode 100644 cmd/gl/main.go create mode 100644 gen/base/v1/msg.pb.go create mode 100644 gen/ledger/v1/msg.pb.go create mode 100644 gen/ledger/v1/srv.pb.go create mode 100644 gen/ledger/v1/srv_grpc.pb.go create mode 100644 gl.cfg.toml create mode 100644 go.mod create mode 100644 go.sum create mode 100644 infrastructure/config/config.go create mode 100644 infrastructure/config/config_test.go create mode 100644 interface/grpc/health.go create mode 100644 interface/grpc/health_test.go create mode 100644 interface/grpc/server.go create mode 100644 interface/grpc/server_test.go diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..0aae601 --- /dev/null +++ b/Makefile @@ -0,0 +1,10 @@ +.PHONY: build generate test + +generate: + buf generate ../proto --template ./buf.gen.yaml --path ../proto/base/v1 --path ../proto/ledger/v1 + +build: generate + go build ./... + +test: + go test ./... diff --git a/README.md b/README.md index c6eb249..0e473a7 100644 --- a/README.md +++ b/README.md @@ -5,3 +5,13 @@ committed wallet value movement so financial state can be reconstructed when a blockchain or provider is unavailable. The implementation contract and invariants are defined in [DESIGN.md](DESIGN.md). + +Generate protobufs, test, and build with: + +```bash +make generate +make test +make build +``` + +Run locally with `go run ./cmd/gl -conf ./gl.cfg.toml`. diff --git a/application/health/service.go b/application/health/service.go new file mode 100644 index 0000000..34f383d --- /dev/null +++ b/application/health/service.go @@ -0,0 +1,29 @@ +// Package health provides the service readiness use case. +package health + +import "context" + +type Database interface { + Ping(context.Context) error +} + +type Status struct { + Serving bool + DatabaseReady bool +} + +type Service struct { + database Database +} + +func NewService(database Database) *Service { + return &Service{database: database} +} + +func (s *Service) Check(ctx context.Context) Status { + status := Status{Serving: true} + if s.database != nil { + status.DatabaseReady = s.database.Ping(ctx) == nil + } + return status +} diff --git a/application/health/service_test.go b/application/health/service_test.go new file mode 100644 index 0000000..26134c4 --- /dev/null +++ b/application/health/service_test.go @@ -0,0 +1,30 @@ +package health + +import ( + "context" + "errors" + "testing" +) + +type databaseStub struct{ err error } + +func (s databaseStub) Ping(context.Context) error { return s.err } + +func TestCheckReportsDatabaseReadiness(t *testing.T) { + for _, tc := range []struct { + name string + db Database + ready bool + }{ + {name: "not connected", db: nil, ready: false}, + {name: "ready", db: databaseStub{}, ready: true}, + {name: "unavailable", db: databaseStub{err: errors.New("down")}, ready: false}, + } { + t.Run(tc.name, func(t *testing.T) { + got := NewService(tc.db).Check(context.Background()) + if !got.Serving || got.DatabaseReady != tc.ready { + t.Fatalf("unexpected status: %+v", got) + } + }) + } +} diff --git a/buf.gen.yaml b/buf.gen.yaml new file mode 100644 index 0000000..a2081fa --- /dev/null +++ b/buf.gen.yaml @@ -0,0 +1,16 @@ +version: v2 +clean: true +managed: + enabled: true + override: + - file_option: go_package_prefix + value: gl/gen +plugins: + - local: protoc-gen-go + out: gen + opt: paths=source_relative + - local: protoc-gen-go-grpc + out: gen + opt: + - paths=source_relative + - require_unimplemented_servers=false diff --git a/cmd/gl/main.go b/cmd/gl/main.go new file mode 100644 index 0000000..7e13b62 --- /dev/null +++ b/cmd/gl/main.go @@ -0,0 +1,40 @@ +package main + +import ( + "context" + "flag" + "log/slog" + "os" + "os/signal" + "syscall" + + "gl/application/health" + "gl/infrastructure/config" + grpcadapter "gl/interface/grpc" +) + +func main() { + configPath := flag.String("conf", "./gl.cfg.toml", "path to the TOML configuration file") + flag.Parse() + + cfg, err := config.Load(*configPath) + if err != nil { + slog.Error("load configuration", "error", err) + os.Exit(1) + } + + ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) + defer stop() + + handler := grpcadapter.NewHealthHandler(health.NewService(nil)) + slog.Info("starting GL gRPC service", "host", cfg.GRPC.Host, "port", cfg.GRPC.Port) + serverConfig := grpcadapter.ServerConfig{ + Host: cfg.GRPC.Host, + Port: cfg.GRPC.Port, + ShutdownTimeout: cfg.GRPC.ShutdownTimeout, + } + if err := grpcadapter.Run(ctx, serverConfig, handler); err != nil { + slog.Error("GL service stopped", "error", err) + os.Exit(1) + } +} diff --git a/gen/base/v1/msg.pb.go b/gen/base/v1/msg.pb.go new file mode 100644 index 0000000..c90445a --- /dev/null +++ b/gen/base/v1/msg.pb.go @@ -0,0 +1,368 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: base/v1/msg.proto + +package basev1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Empty struct { + state protoimpl.MessageState `protogen:"open.v1"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Empty) Reset() { + *x = Empty{} + mi := &file_base_v1_msg_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Empty) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Empty) ProtoMessage() {} + +func (x *Empty) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Empty.ProtoReflect.Descriptor instead. +func (*Empty) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{0} +} + +type StatusRes struct { + state protoimpl.MessageState `protogen:"open.v1"` + Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StatusRes) Reset() { + *x = StatusRes{} + mi := &file_base_v1_msg_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StatusRes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StatusRes) ProtoMessage() {} + +func (x *StatusRes) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use StatusRes.ProtoReflect.Descriptor instead. +func (*StatusRes) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{1} +} + +func (x *StatusRes) GetSuccess() bool { + if x != nil { + return x.Success + } + return false +} + +type IdRes struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IdRes) Reset() { + *x = IdRes{} + mi := &file_base_v1_msg_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IdRes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdRes) ProtoMessage() {} + +func (x *IdRes) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdRes.ProtoReflect.Descriptor instead. +func (*IdRes) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{2} +} + +func (x *IdRes) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type IdReq struct { + state protoimpl.MessageState `protogen:"open.v1"` + Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IdReq) Reset() { + *x = IdReq{} + mi := &file_base_v1_msg_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IdReq) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IdReq) ProtoMessage() {} + +func (x *IdReq) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IdReq.ProtoReflect.Descriptor instead. +func (*IdReq) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{3} +} + +func (x *IdReq) GetId() int64 { + if x != nil { + return x.Id + } + return 0 +} + +type YesNoRes struct { + state protoimpl.MessageState `protogen:"open.v1"` + Yes bool `protobuf:"varint,1,opt,name=yes,proto3" json:"yes,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *YesNoRes) Reset() { + *x = YesNoRes{} + mi := &file_base_v1_msg_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *YesNoRes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*YesNoRes) ProtoMessage() {} + +func (x *YesNoRes) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use YesNoRes.ProtoReflect.Descriptor instead. +func (*YesNoRes) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{4} +} + +func (x *YesNoRes) GetYes() bool { + if x != nil { + return x.Yes + } + return false +} + +type PaginationRespSample struct { + state protoimpl.MessageState `protogen:"open.v1"` + PageNo uint32 `protobuf:"varint,2,opt,name=page_no,json=pageNo,proto3" json:"page_no,omitempty"` + PageSize uint32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + TotalCount uint32 `protobuf:"varint,4,opt,name=total_count,json=totalCount,proto3" json:"total_count,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PaginationRespSample) Reset() { + *x = PaginationRespSample{} + mi := &file_base_v1_msg_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PaginationRespSample) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PaginationRespSample) ProtoMessage() {} + +func (x *PaginationRespSample) ProtoReflect() protoreflect.Message { + mi := &file_base_v1_msg_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PaginationRespSample.ProtoReflect.Descriptor instead. +func (*PaginationRespSample) Descriptor() ([]byte, []int) { + return file_base_v1_msg_proto_rawDescGZIP(), []int{5} +} + +func (x *PaginationRespSample) GetPageNo() uint32 { + if x != nil { + return x.PageNo + } + return 0 +} + +func (x *PaginationRespSample) GetPageSize() uint32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *PaginationRespSample) GetTotalCount() uint32 { + if x != nil { + return x.TotalCount + } + return 0 +} + +var File_base_v1_msg_proto protoreflect.FileDescriptor + +const file_base_v1_msg_proto_rawDesc = "" + + "\n" + + "\x11base/v1/msg.proto\x12\abase.v1\"\a\n" + + "\x05Empty\"%\n" + + "\tStatusRes\x12\x18\n" + + "\asuccess\x18\x01 \x01(\bR\asuccess\"\x17\n" + + "\x05IdRes\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\"\x17\n" + + "\x05IdReq\x12\x0e\n" + + "\x02id\x18\x01 \x01(\x03R\x02id\"\x1c\n" + + "\bYesNoRes\x12\x10\n" + + "\x03yes\x18\x01 \x01(\bR\x03yes\"m\n" + + "\x14PaginationRespSample\x12\x17\n" + + "\apage_no\x18\x02 \x01(\rR\x06pageNo\x12\x1b\n" + + "\tpage_size\x18\x03 \x01(\rR\bpageSize\x12\x1f\n" + + "\vtotal_count\x18\x04 \x01(\rR\n" + + "totalCountBk\n" + + "\vcom.base.v1B\bMsgProtoP\x01Z\x15gl/gen/base/v1;basev1\xa2\x02\x03BXX\xaa\x02\aBase.V1\xca\x02\aBase\\V1\xe2\x02\x13Base\\V1\\GPBMetadata\xea\x02\bBase::V1b\x06proto3" + +var ( + file_base_v1_msg_proto_rawDescOnce sync.Once + file_base_v1_msg_proto_rawDescData []byte +) + +func file_base_v1_msg_proto_rawDescGZIP() []byte { + file_base_v1_msg_proto_rawDescOnce.Do(func() { + file_base_v1_msg_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_base_v1_msg_proto_rawDesc), len(file_base_v1_msg_proto_rawDesc))) + }) + return file_base_v1_msg_proto_rawDescData +} + +var file_base_v1_msg_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_base_v1_msg_proto_goTypes = []any{ + (*Empty)(nil), // 0: base.v1.Empty + (*StatusRes)(nil), // 1: base.v1.StatusRes + (*IdRes)(nil), // 2: base.v1.IdRes + (*IdReq)(nil), // 3: base.v1.IdReq + (*YesNoRes)(nil), // 4: base.v1.YesNoRes + (*PaginationRespSample)(nil), // 5: base.v1.PaginationRespSample +} +var file_base_v1_msg_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_base_v1_msg_proto_init() } +func file_base_v1_msg_proto_init() { + if File_base_v1_msg_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_base_v1_msg_proto_rawDesc), len(file_base_v1_msg_proto_rawDesc)), + NumEnums: 0, + NumMessages: 6, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_base_v1_msg_proto_goTypes, + DependencyIndexes: file_base_v1_msg_proto_depIdxs, + MessageInfos: file_base_v1_msg_proto_msgTypes, + }.Build() + File_base_v1_msg_proto = out.File + file_base_v1_msg_proto_goTypes = nil + file_base_v1_msg_proto_depIdxs = nil +} diff --git a/gen/ledger/v1/msg.pb.go b/gen/ledger/v1/msg.pb.go new file mode 100644 index 0000000..2c39792 --- /dev/null +++ b/gen/ledger/v1/msg.pb.go @@ -0,0 +1,1767 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: ledger/v1/msg.proto + +package ledgerv1 + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type AccountClass int32 + +const ( + AccountClass_ACCOUNT_CLASS_UNSPECIFIED AccountClass = 0 + AccountClass_ACCOUNT_CLASS_USER_AVAILABLE AccountClass = 1 + AccountClass_ACCOUNT_CLASS_USER_FROZEN AccountClass = 2 + AccountClass_ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN AccountClass = 3 + AccountClass_ACCOUNT_CLASS_TREASURY AccountClass = 4 + AccountClass_ACCOUNT_CLASS_MARKET_CLEARING AccountClass = 5 + AccountClass_ACCOUNT_CLASS_IPG_CLEARING AccountClass = 6 + AccountClass_ACCOUNT_CLASS_COMMISSION_REVENUE AccountClass = 7 +) + +// Enum value maps for AccountClass. +var ( + AccountClass_name = map[int32]string{ + 0: "ACCOUNT_CLASS_UNSPECIFIED", + 1: "ACCOUNT_CLASS_USER_AVAILABLE", + 2: "ACCOUNT_CLASS_USER_FROZEN", + 3: "ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN", + 4: "ACCOUNT_CLASS_TREASURY", + 5: "ACCOUNT_CLASS_MARKET_CLEARING", + 6: "ACCOUNT_CLASS_IPG_CLEARING", + 7: "ACCOUNT_CLASS_COMMISSION_REVENUE", + } + AccountClass_value = map[string]int32{ + "ACCOUNT_CLASS_UNSPECIFIED": 0, + "ACCOUNT_CLASS_USER_AVAILABLE": 1, + "ACCOUNT_CLASS_USER_FROZEN": 2, + "ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN": 3, + "ACCOUNT_CLASS_TREASURY": 4, + "ACCOUNT_CLASS_MARKET_CLEARING": 5, + "ACCOUNT_CLASS_IPG_CLEARING": 6, + "ACCOUNT_CLASS_COMMISSION_REVENUE": 7, + } +) + +func (x AccountClass) Enum() *AccountClass { + p := new(AccountClass) + *p = x + return p +} + +func (x AccountClass) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (AccountClass) Descriptor() protoreflect.EnumDescriptor { + return file_ledger_v1_msg_proto_enumTypes[0].Descriptor() +} + +func (AccountClass) Type() protoreflect.EnumType { + return &file_ledger_v1_msg_proto_enumTypes[0] +} + +func (x AccountClass) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use AccountClass.Descriptor instead. +func (AccountClass) EnumDescriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{0} +} + +type TransactionState int32 + +const ( + TransactionState_TRANSACTION_STATE_UNSPECIFIED TransactionState = 0 + TransactionState_TRANSACTION_STATE_CREATED TransactionState = 1 + TransactionState_TRANSACTION_STATE_PENDING_TRANSACTION TransactionState = 2 + TransactionState_TRANSACTION_STATE_PENDING_ADMIN TransactionState = 3 + TransactionState_TRANSACTION_STATE_SUCCESSFUL TransactionState = 4 + TransactionState_TRANSACTION_STATE_FAILED TransactionState = 5 + TransactionState_TRANSACTION_STATE_SUSPENDED TransactionState = 6 +) + +// Enum value maps for TransactionState. +var ( + TransactionState_name = map[int32]string{ + 0: "TRANSACTION_STATE_UNSPECIFIED", + 1: "TRANSACTION_STATE_CREATED", + 2: "TRANSACTION_STATE_PENDING_TRANSACTION", + 3: "TRANSACTION_STATE_PENDING_ADMIN", + 4: "TRANSACTION_STATE_SUCCESSFUL", + 5: "TRANSACTION_STATE_FAILED", + 6: "TRANSACTION_STATE_SUSPENDED", + } + TransactionState_value = map[string]int32{ + "TRANSACTION_STATE_UNSPECIFIED": 0, + "TRANSACTION_STATE_CREATED": 1, + "TRANSACTION_STATE_PENDING_TRANSACTION": 2, + "TRANSACTION_STATE_PENDING_ADMIN": 3, + "TRANSACTION_STATE_SUCCESSFUL": 4, + "TRANSACTION_STATE_FAILED": 5, + "TRANSACTION_STATE_SUSPENDED": 6, + } +) + +func (x TransactionState) Enum() *TransactionState { + p := new(TransactionState) + *p = x + return p +} + +func (x TransactionState) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TransactionState) Descriptor() protoreflect.EnumDescriptor { + return file_ledger_v1_msg_proto_enumTypes[1].Descriptor() +} + +func (TransactionState) Type() protoreflect.EnumType { + return &file_ledger_v1_msg_proto_enumTypes[1] +} + +func (x TransactionState) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use TransactionState.Descriptor instead. +func (TransactionState) EnumDescriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{1} +} + +type AccountReference struct { + state protoimpl.MessageState `protogen:"open.v1"` + AccountClass AccountClass `protobuf:"varint,1,opt,name=account_class,json=accountClass,proto3,enum=ledger.v1.AccountClass" json:"account_class,omitempty"` + OwnerType string `protobuf:"bytes,2,opt,name=owner_type,json=ownerType,proto3" json:"owner_type,omitempty"` + OwnerId string `protobuf:"bytes,3,opt,name=owner_id,json=ownerId,proto3" json:"owner_id,omitempty"` + AssetId int64 `protobuf:"varint,4,opt,name=asset_id,json=assetId,proto3" json:"asset_id,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AccountReference) Reset() { + *x = AccountReference{} + mi := &file_ledger_v1_msg_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AccountReference) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AccountReference) ProtoMessage() {} + +func (x *AccountReference) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AccountReference.ProtoReflect.Descriptor instead. +func (*AccountReference) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{0} +} + +func (x *AccountReference) GetAccountClass() AccountClass { + if x != nil { + return x.AccountClass + } + return AccountClass_ACCOUNT_CLASS_UNSPECIFIED +} + +func (x *AccountReference) GetOwnerType() string { + if x != nil { + return x.OwnerType + } + return "" +} + +func (x *AccountReference) GetOwnerId() string { + if x != nil { + return x.OwnerId + } + return "" +} + +func (x *AccountReference) GetAssetId() int64 { + if x != nil { + return x.AssetId + } + return 0 +} + +type JournalEntry struct { + state protoimpl.MessageState `protogen:"open.v1"` + LineNumber uint32 `protobuf:"varint,1,opt,name=line_number,json=lineNumber,proto3" json:"line_number,omitempty"` + Account *AccountReference `protobuf:"bytes,2,opt,name=account,proto3" json:"account,omitempty"` + // Canonical base-10 decimal. Positive is credit and negative is debit. + Amount string `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"` + Description string `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *JournalEntry) Reset() { + *x = JournalEntry{} + mi := &file_ledger_v1_msg_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *JournalEntry) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JournalEntry) ProtoMessage() {} + +func (x *JournalEntry) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[1] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JournalEntry.ProtoReflect.Descriptor instead. +func (*JournalEntry) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{1} +} + +func (x *JournalEntry) GetLineNumber() uint32 { + if x != nil { + return x.LineNumber + } + return 0 +} + +func (x *JournalEntry) GetAccount() *AccountReference { + if x != nil { + return x.Account + } + return nil +} + +func (x *JournalEntry) GetAmount() string { + if x != nil { + return x.Amount + } + return "" +} + +func (x *JournalEntry) GetDescription() string { + if x != nil { + return x.Description + } + return "" +} + +type BlockchainReference struct { + state protoimpl.MessageState `protogen:"open.v1"` + Network string `protobuf:"bytes,1,opt,name=network,proto3" json:"network,omitempty"` + TransactionHash string `protobuf:"bytes,2,opt,name=transaction_hash,json=transactionHash,proto3" json:"transaction_hash,omitempty"` + LedgerSequence string `protobuf:"bytes,3,opt,name=ledger_sequence,json=ledgerSequence,proto3" json:"ledger_sequence,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BlockchainReference) Reset() { + *x = BlockchainReference{} + mi := &file_ledger_v1_msg_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BlockchainReference) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BlockchainReference) ProtoMessage() {} + +func (x *BlockchainReference) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BlockchainReference.ProtoReflect.Descriptor instead. +func (*BlockchainReference) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{2} +} + +func (x *BlockchainReference) GetNetwork() string { + if x != nil { + return x.Network + } + return "" +} + +func (x *BlockchainReference) GetTransactionHash() string { + if x != nil { + return x.TransactionHash + } + return "" +} + +func (x *BlockchainReference) GetLedgerSequence() string { + if x != nil { + return x.LedgerSequence + } + return "" +} + +type Journal struct { + state protoimpl.MessageState `protogen:"open.v1"` + JournalId string `protobuf:"bytes,1,opt,name=journal_id,json=journalId,proto3" json:"journal_id,omitempty"` + SourceService string `protobuf:"bytes,2,opt,name=source_service,json=sourceService,proto3" json:"source_service,omitempty"` + IdempotencyKey string `protobuf:"bytes,3,opt,name=idempotency_key,json=idempotencyKey,proto3" json:"idempotency_key,omitempty"` + SourceTransactionId string `protobuf:"bytes,4,opt,name=source_transaction_id,json=sourceTransactionId,proto3" json:"source_transaction_id,omitempty"` + TrackingCode string `protobuf:"bytes,5,opt,name=tracking_code,json=trackingCode,proto3" json:"tracking_code,omitempty"` + EffectKind string `protobuf:"bytes,6,opt,name=effect_kind,json=effectKind,proto3" json:"effect_kind,omitempty"` + EventVersion uint32 `protobuf:"varint,7,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"` + Entries []*JournalEntry `protobuf:"bytes,8,rep,name=entries,proto3" json:"entries,omitempty"` + ReversalOfJournalId *string `protobuf:"bytes,9,opt,name=reversal_of_journal_id,json=reversalOfJournalId,proto3,oneof" json:"reversal_of_journal_id,omitempty"` + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,10,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + RecordedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=recorded_at,json=recordedAt,proto3" json:"recorded_at,omitempty"` + CorrelationId string `protobuf:"bytes,12,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"` + ActorId string `protobuf:"bytes,13,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Blockchain *BlockchainReference `protobuf:"bytes,14,opt,name=blockchain,proto3" json:"blockchain,omitempty"` + Metadata map[string]string `protobuf:"bytes,15,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + PayloadHash string `protobuf:"bytes,16,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Journal) Reset() { + *x = Journal{} + mi := &file_ledger_v1_msg_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Journal) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Journal) ProtoMessage() {} + +func (x *Journal) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[3] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Journal.ProtoReflect.Descriptor instead. +func (*Journal) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{3} +} + +func (x *Journal) GetJournalId() string { + if x != nil { + return x.JournalId + } + return "" +} + +func (x *Journal) GetSourceService() string { + if x != nil { + return x.SourceService + } + return "" +} + +func (x *Journal) GetIdempotencyKey() string { + if x != nil { + return x.IdempotencyKey + } + return "" +} + +func (x *Journal) GetSourceTransactionId() string { + if x != nil { + return x.SourceTransactionId + } + return "" +} + +func (x *Journal) GetTrackingCode() string { + if x != nil { + return x.TrackingCode + } + return "" +} + +func (x *Journal) GetEffectKind() string { + if x != nil { + return x.EffectKind + } + return "" +} + +func (x *Journal) GetEventVersion() uint32 { + if x != nil { + return x.EventVersion + } + return 0 +} + +func (x *Journal) GetEntries() []*JournalEntry { + if x != nil { + return x.Entries + } + return nil +} + +func (x *Journal) GetReversalOfJournalId() string { + if x != nil && x.ReversalOfJournalId != nil { + return *x.ReversalOfJournalId + } + return "" +} + +func (x *Journal) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (x *Journal) GetRecordedAt() *timestamppb.Timestamp { + if x != nil { + return x.RecordedAt + } + return nil +} + +func (x *Journal) GetCorrelationId() string { + if x != nil { + return x.CorrelationId + } + return "" +} + +func (x *Journal) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *Journal) GetBlockchain() *BlockchainReference { + if x != nil { + return x.Blockchain + } + return nil +} + +func (x *Journal) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *Journal) GetPayloadHash() string { + if x != nil { + return x.PayloadHash + } + return "" +} + +type AppendJournalRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + SourceService string `protobuf:"bytes,1,opt,name=source_service,json=sourceService,proto3" json:"source_service,omitempty"` + IdempotencyKey string `protobuf:"bytes,2,opt,name=idempotency_key,json=idempotencyKey,proto3" json:"idempotency_key,omitempty"` + SourceTransactionId string `protobuf:"bytes,3,opt,name=source_transaction_id,json=sourceTransactionId,proto3" json:"source_transaction_id,omitempty"` + TrackingCode string `protobuf:"bytes,4,opt,name=tracking_code,json=trackingCode,proto3" json:"tracking_code,omitempty"` + EffectKind string `protobuf:"bytes,5,opt,name=effect_kind,json=effectKind,proto3" json:"effect_kind,omitempty"` + EventVersion uint32 `protobuf:"varint,6,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"` + Entries []*JournalEntry `protobuf:"bytes,7,rep,name=entries,proto3" json:"entries,omitempty"` + ReversalOfJournalId *string `protobuf:"bytes,8,opt,name=reversal_of_journal_id,json=reversalOfJournalId,proto3,oneof" json:"reversal_of_journal_id,omitempty"` + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + CorrelationId string `protobuf:"bytes,10,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"` + ActorId string `protobuf:"bytes,11,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Blockchain *BlockchainReference `protobuf:"bytes,12,opt,name=blockchain,proto3" json:"blockchain,omitempty"` + Metadata map[string]string `protobuf:"bytes,13,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendJournalRequest) Reset() { + *x = AppendJournalRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendJournalRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendJournalRequest) ProtoMessage() {} + +func (x *AppendJournalRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[4] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendJournalRequest.ProtoReflect.Descriptor instead. +func (*AppendJournalRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{4} +} + +func (x *AppendJournalRequest) GetSourceService() string { + if x != nil { + return x.SourceService + } + return "" +} + +func (x *AppendJournalRequest) GetIdempotencyKey() string { + if x != nil { + return x.IdempotencyKey + } + return "" +} + +func (x *AppendJournalRequest) GetSourceTransactionId() string { + if x != nil { + return x.SourceTransactionId + } + return "" +} + +func (x *AppendJournalRequest) GetTrackingCode() string { + if x != nil { + return x.TrackingCode + } + return "" +} + +func (x *AppendJournalRequest) GetEffectKind() string { + if x != nil { + return x.EffectKind + } + return "" +} + +func (x *AppendJournalRequest) GetEventVersion() uint32 { + if x != nil { + return x.EventVersion + } + return 0 +} + +func (x *AppendJournalRequest) GetEntries() []*JournalEntry { + if x != nil { + return x.Entries + } + return nil +} + +func (x *AppendJournalRequest) GetReversalOfJournalId() string { + if x != nil && x.ReversalOfJournalId != nil { + return *x.ReversalOfJournalId + } + return "" +} + +func (x *AppendJournalRequest) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (x *AppendJournalRequest) GetCorrelationId() string { + if x != nil { + return x.CorrelationId + } + return "" +} + +func (x *AppendJournalRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *AppendJournalRequest) GetBlockchain() *BlockchainReference { + if x != nil { + return x.Blockchain + } + return nil +} + +func (x *AppendJournalRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +type AppendJournalResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Journal *Journal `protobuf:"bytes,1,opt,name=journal,proto3" json:"journal,omitempty"` + AlreadyExisted bool `protobuf:"varint,2,opt,name=already_existed,json=alreadyExisted,proto3" json:"already_existed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendJournalResponse) Reset() { + *x = AppendJournalResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendJournalResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendJournalResponse) ProtoMessage() {} + +func (x *AppendJournalResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendJournalResponse.ProtoReflect.Descriptor instead. +func (*AppendJournalResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{5} +} + +func (x *AppendJournalResponse) GetJournal() *Journal { + if x != nil { + return x.Journal + } + return nil +} + +func (x *AppendJournalResponse) GetAlreadyExisted() bool { + if x != nil { + return x.AlreadyExisted + } + return false +} + +type AppendTransactionEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + SourceService string `protobuf:"bytes,1,opt,name=source_service,json=sourceService,proto3" json:"source_service,omitempty"` + IdempotencyKey string `protobuf:"bytes,2,opt,name=idempotency_key,json=idempotencyKey,proto3" json:"idempotency_key,omitempty"` + SourceTransactionId string `protobuf:"bytes,3,opt,name=source_transaction_id,json=sourceTransactionId,proto3" json:"source_transaction_id,omitempty"` + TrackingCode string `protobuf:"bytes,4,opt,name=tracking_code,json=trackingCode,proto3" json:"tracking_code,omitempty"` + EventVersion uint32 `protobuf:"varint,5,opt,name=event_version,json=eventVersion,proto3" json:"event_version,omitempty"` + State TransactionState `protobuf:"varint,6,opt,name=state,proto3,enum=ledger.v1.TransactionState" json:"state,omitempty"` + ErrorCode string `protobuf:"bytes,7,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty"` + ErrorMessage string `protobuf:"bytes,8,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty"` + OccurredAt *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=occurred_at,json=occurredAt,proto3" json:"occurred_at,omitempty"` + CorrelationId string `protobuf:"bytes,10,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"` + ActorId string `protobuf:"bytes,11,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + Blockchain *BlockchainReference `protobuf:"bytes,12,opt,name=blockchain,proto3" json:"blockchain,omitempty"` + Metadata map[string]string `protobuf:"bytes,13,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendTransactionEventRequest) Reset() { + *x = AppendTransactionEventRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendTransactionEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendTransactionEventRequest) ProtoMessage() {} + +func (x *AppendTransactionEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendTransactionEventRequest.ProtoReflect.Descriptor instead. +func (*AppendTransactionEventRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{6} +} + +func (x *AppendTransactionEventRequest) GetSourceService() string { + if x != nil { + return x.SourceService + } + return "" +} + +func (x *AppendTransactionEventRequest) GetIdempotencyKey() string { + if x != nil { + return x.IdempotencyKey + } + return "" +} + +func (x *AppendTransactionEventRequest) GetSourceTransactionId() string { + if x != nil { + return x.SourceTransactionId + } + return "" +} + +func (x *AppendTransactionEventRequest) GetTrackingCode() string { + if x != nil { + return x.TrackingCode + } + return "" +} + +func (x *AppendTransactionEventRequest) GetEventVersion() uint32 { + if x != nil { + return x.EventVersion + } + return 0 +} + +func (x *AppendTransactionEventRequest) GetState() TransactionState { + if x != nil { + return x.State + } + return TransactionState_TRANSACTION_STATE_UNSPECIFIED +} + +func (x *AppendTransactionEventRequest) GetErrorCode() string { + if x != nil { + return x.ErrorCode + } + return "" +} + +func (x *AppendTransactionEventRequest) GetErrorMessage() string { + if x != nil { + return x.ErrorMessage + } + return "" +} + +func (x *AppendTransactionEventRequest) GetOccurredAt() *timestamppb.Timestamp { + if x != nil { + return x.OccurredAt + } + return nil +} + +func (x *AppendTransactionEventRequest) GetCorrelationId() string { + if x != nil { + return x.CorrelationId + } + return "" +} + +func (x *AppendTransactionEventRequest) GetActorId() string { + if x != nil { + return x.ActorId + } + return "" +} + +func (x *AppendTransactionEventRequest) GetBlockchain() *BlockchainReference { + if x != nil { + return x.Blockchain + } + return nil +} + +func (x *AppendTransactionEventRequest) GetMetadata() map[string]string { + if x != nil { + return x.Metadata + } + return nil +} + +type TransactionEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + EventId string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"` + Event *AppendTransactionEventRequest `protobuf:"bytes,2,opt,name=event,proto3" json:"event,omitempty"` + RecordedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=recorded_at,json=recordedAt,proto3" json:"recorded_at,omitempty"` + PayloadHash string `protobuf:"bytes,4,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *TransactionEvent) Reset() { + *x = TransactionEvent{} + mi := &file_ledger_v1_msg_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *TransactionEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TransactionEvent) ProtoMessage() {} + +func (x *TransactionEvent) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[7] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TransactionEvent.ProtoReflect.Descriptor instead. +func (*TransactionEvent) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{7} +} + +func (x *TransactionEvent) GetEventId() string { + if x != nil { + return x.EventId + } + return "" +} + +func (x *TransactionEvent) GetEvent() *AppendTransactionEventRequest { + if x != nil { + return x.Event + } + return nil +} + +func (x *TransactionEvent) GetRecordedAt() *timestamppb.Timestamp { + if x != nil { + return x.RecordedAt + } + return nil +} + +func (x *TransactionEvent) GetPayloadHash() string { + if x != nil { + return x.PayloadHash + } + return "" +} + +type AppendTransactionEventResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Event *TransactionEvent `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"` + AlreadyExisted bool `protobuf:"varint,2,opt,name=already_existed,json=alreadyExisted,proto3" json:"already_existed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AppendTransactionEventResponse) Reset() { + *x = AppendTransactionEventResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AppendTransactionEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AppendTransactionEventResponse) ProtoMessage() {} + +func (x *AppendTransactionEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[8] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use AppendTransactionEventResponse.ProtoReflect.Descriptor instead. +func (*AppendTransactionEventResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{8} +} + +func (x *AppendTransactionEventResponse) GetEvent() *TransactionEvent { + if x != nil { + return x.Event + } + return nil +} + +func (x *AppendTransactionEventResponse) GetAlreadyExisted() bool { + if x != nil { + return x.AlreadyExisted + } + return false +} + +type GetJournalRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Types that are valid to be assigned to Lookup: + // + // *GetJournalRequest_JournalId + // *GetJournalRequest_IdempotencyKey + Lookup isGetJournalRequest_Lookup `protobuf_oneof:"lookup"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetJournalRequest) Reset() { + *x = GetJournalRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetJournalRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetJournalRequest) ProtoMessage() {} + +func (x *GetJournalRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[9] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetJournalRequest.ProtoReflect.Descriptor instead. +func (*GetJournalRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{9} +} + +func (x *GetJournalRequest) GetLookup() isGetJournalRequest_Lookup { + if x != nil { + return x.Lookup + } + return nil +} + +func (x *GetJournalRequest) GetJournalId() string { + if x != nil { + if x, ok := x.Lookup.(*GetJournalRequest_JournalId); ok { + return x.JournalId + } + } + return "" +} + +func (x *GetJournalRequest) GetIdempotencyKey() string { + if x != nil { + if x, ok := x.Lookup.(*GetJournalRequest_IdempotencyKey); ok { + return x.IdempotencyKey + } + } + return "" +} + +type isGetJournalRequest_Lookup interface { + isGetJournalRequest_Lookup() +} + +type GetJournalRequest_JournalId struct { + JournalId string `protobuf:"bytes,1,opt,name=journal_id,json=journalId,proto3,oneof"` +} + +type GetJournalRequest_IdempotencyKey struct { + IdempotencyKey string `protobuf:"bytes,2,opt,name=idempotency_key,json=idempotencyKey,proto3,oneof"` +} + +func (*GetJournalRequest_JournalId) isGetJournalRequest_Lookup() {} + +func (*GetJournalRequest_IdempotencyKey) isGetJournalRequest_Lookup() {} + +type ListEntriesRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Account *AccountReference `protobuf:"bytes,1,opt,name=account,proto3,oneof" json:"account,omitempty"` + AssetId *int64 `protobuf:"varint,2,opt,name=asset_id,json=assetId,proto3,oneof" json:"asset_id,omitempty"` + RecordedFrom *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=recorded_from,json=recordedFrom,proto3" json:"recorded_from,omitempty"` + RecordedTo *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=recorded_to,json=recordedTo,proto3" json:"recorded_to,omitempty"` + PageSize uint32 `protobuf:"varint,5,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` + PageToken string `protobuf:"bytes,6,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListEntriesRequest) Reset() { + *x = ListEntriesRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListEntriesRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListEntriesRequest) ProtoMessage() {} + +func (x *ListEntriesRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[10] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListEntriesRequest.ProtoReflect.Descriptor instead. +func (*ListEntriesRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{10} +} + +func (x *ListEntriesRequest) GetAccount() *AccountReference { + if x != nil { + return x.Account + } + return nil +} + +func (x *ListEntriesRequest) GetAssetId() int64 { + if x != nil && x.AssetId != nil { + return *x.AssetId + } + return 0 +} + +func (x *ListEntriesRequest) GetRecordedFrom() *timestamppb.Timestamp { + if x != nil { + return x.RecordedFrom + } + return nil +} + +func (x *ListEntriesRequest) GetRecordedTo() *timestamppb.Timestamp { + if x != nil { + return x.RecordedTo + } + return nil +} + +func (x *ListEntriesRequest) GetPageSize() uint32 { + if x != nil { + return x.PageSize + } + return 0 +} + +func (x *ListEntriesRequest) GetPageToken() string { + if x != nil { + return x.PageToken + } + return "" +} + +type ListEntriesResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Journals []*Journal `protobuf:"bytes,1,rep,name=journals,proto3" json:"journals,omitempty"` + NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListEntriesResponse) Reset() { + *x = ListEntriesResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListEntriesResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListEntriesResponse) ProtoMessage() {} + +func (x *ListEntriesResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[11] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListEntriesResponse.ProtoReflect.Descriptor instead. +func (*ListEntriesResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{11} +} + +func (x *ListEntriesResponse) GetJournals() []*Journal { + if x != nil { + return x.Journals + } + return nil +} + +func (x *ListEntriesResponse) GetNextPageToken() string { + if x != nil { + return x.NextPageToken + } + return "" +} + +type GetBalanceRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Account *AccountReference `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` + AsOf *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=as_of,json=asOf,proto3" json:"as_of,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBalanceRequest) Reset() { + *x = GetBalanceRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBalanceRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBalanceRequest) ProtoMessage() {} + +func (x *GetBalanceRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[12] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBalanceRequest.ProtoReflect.Descriptor instead. +func (*GetBalanceRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{12} +} + +func (x *GetBalanceRequest) GetAccount() *AccountReference { + if x != nil { + return x.Account + } + return nil +} + +func (x *GetBalanceRequest) GetAsOf() *timestamppb.Timestamp { + if x != nil { + return x.AsOf + } + return nil +} + +type GetBalanceResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Account *AccountReference `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"` + // Canonical base-10 decimal reconstructed from immutable entries. + Balance string `protobuf:"bytes,2,opt,name=balance,proto3" json:"balance,omitempty"` + AsOf *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=as_of,json=asOf,proto3" json:"as_of,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetBalanceResponse) Reset() { + *x = GetBalanceResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetBalanceResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetBalanceResponse) ProtoMessage() {} + +func (x *GetBalanceResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[13] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GetBalanceResponse.ProtoReflect.Descriptor instead. +func (*GetBalanceResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{13} +} + +func (x *GetBalanceResponse) GetAccount() *AccountReference { + if x != nil { + return x.Account + } + return nil +} + +func (x *GetBalanceResponse) GetBalance() string { + if x != nil { + return x.Balance + } + return "" +} + +func (x *GetBalanceResponse) GetAsOf() *timestamppb.Timestamp { + if x != nil { + return x.AsOf + } + return nil +} + +type ReplayJournalsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Each item is independently atomic and uses normal append idempotency. + Journals []*AppendJournalRequest `protobuf:"bytes,1,rep,name=journals,proto3" json:"journals,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReplayJournalsRequest) Reset() { + *x = ReplayJournalsRequest{} + mi := &file_ledger_v1_msg_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplayJournalsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplayJournalsRequest) ProtoMessage() {} + +func (x *ReplayJournalsRequest) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[14] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplayJournalsRequest.ProtoReflect.Descriptor instead. +func (*ReplayJournalsRequest) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{14} +} + +func (x *ReplayJournalsRequest) GetJournals() []*AppendJournalRequest { + if x != nil { + return x.Journals + } + return nil +} + +type ReplayJournalResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + IdempotencyKey string `protobuf:"bytes,1,opt,name=idempotency_key,json=idempotencyKey,proto3" json:"idempotency_key,omitempty"` + Journal *Journal `protobuf:"bytes,2,opt,name=journal,proto3" json:"journal,omitempty"` + AlreadyExisted bool `protobuf:"varint,3,opt,name=already_existed,json=alreadyExisted,proto3" json:"already_existed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReplayJournalResult) Reset() { + *x = ReplayJournalResult{} + mi := &file_ledger_v1_msg_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplayJournalResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplayJournalResult) ProtoMessage() {} + +func (x *ReplayJournalResult) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[15] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplayJournalResult.ProtoReflect.Descriptor instead. +func (*ReplayJournalResult) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{15} +} + +func (x *ReplayJournalResult) GetIdempotencyKey() string { + if x != nil { + return x.IdempotencyKey + } + return "" +} + +func (x *ReplayJournalResult) GetJournal() *Journal { + if x != nil { + return x.Journal + } + return nil +} + +func (x *ReplayJournalResult) GetAlreadyExisted() bool { + if x != nil { + return x.AlreadyExisted + } + return false +} + +type ReplayJournalsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Results []*ReplayJournalResult `protobuf:"bytes,1,rep,name=results,proto3" json:"results,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ReplayJournalsResponse) Reset() { + *x = ReplayJournalsResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ReplayJournalsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ReplayJournalsResponse) ProtoMessage() {} + +func (x *ReplayJournalsResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[16] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ReplayJournalsResponse.ProtoReflect.Descriptor instead. +func (*ReplayJournalsResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{16} +} + +func (x *ReplayJournalsResponse) GetResults() []*ReplayJournalResult { + if x != nil { + return x.Results + } + return nil +} + +type HealthResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Serving bool `protobuf:"varint,1,opt,name=serving,proto3" json:"serving,omitempty"` + DatabaseReady bool `protobuf:"varint,2,opt,name=database_ready,json=databaseReady,proto3" json:"database_ready,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HealthResponse) Reset() { + *x = HealthResponse{} + mi := &file_ledger_v1_msg_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HealthResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HealthResponse) ProtoMessage() {} + +func (x *HealthResponse) ProtoReflect() protoreflect.Message { + mi := &file_ledger_v1_msg_proto_msgTypes[17] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use HealthResponse.ProtoReflect.Descriptor instead. +func (*HealthResponse) Descriptor() ([]byte, []int) { + return file_ledger_v1_msg_proto_rawDescGZIP(), []int{17} +} + +func (x *HealthResponse) GetServing() bool { + if x != nil { + return x.Serving + } + return false +} + +func (x *HealthResponse) GetDatabaseReady() bool { + if x != nil { + return x.DatabaseReady + } + return false +} + +var File_ledger_v1_msg_proto protoreflect.FileDescriptor + +const file_ledger_v1_msg_proto_rawDesc = "" + + "\n" + + "\x13ledger/v1/msg.proto\x12\tledger.v1\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa5\x01\n" + + "\x10AccountReference\x12<\n" + + "\raccount_class\x18\x01 \x01(\x0e2\x17.ledger.v1.AccountClassR\faccountClass\x12\x1d\n" + + "\n" + + "owner_type\x18\x02 \x01(\tR\townerType\x12\x19\n" + + "\bowner_id\x18\x03 \x01(\tR\aownerId\x12\x19\n" + + "\basset_id\x18\x04 \x01(\x03R\aassetId\"\xa0\x01\n" + + "\fJournalEntry\x12\x1f\n" + + "\vline_number\x18\x01 \x01(\rR\n" + + "lineNumber\x125\n" + + "\aaccount\x18\x02 \x01(\v2\x1b.ledger.v1.AccountReferenceR\aaccount\x12\x16\n" + + "\x06amount\x18\x03 \x01(\tR\x06amount\x12 \n" + + "\vdescription\x18\x04 \x01(\tR\vdescription\"\x83\x01\n" + + "\x13BlockchainReference\x12\x18\n" + + "\anetwork\x18\x01 \x01(\tR\anetwork\x12)\n" + + "\x10transaction_hash\x18\x02 \x01(\tR\x0ftransactionHash\x12'\n" + + "\x0fledger_sequence\x18\x03 \x01(\tR\x0eledgerSequence\"\xb9\x06\n" + + "\aJournal\x12\x1d\n" + + "\n" + + "journal_id\x18\x01 \x01(\tR\tjournalId\x12%\n" + + "\x0esource_service\x18\x02 \x01(\tR\rsourceService\x12'\n" + + "\x0fidempotency_key\x18\x03 \x01(\tR\x0eidempotencyKey\x122\n" + + "\x15source_transaction_id\x18\x04 \x01(\tR\x13sourceTransactionId\x12#\n" + + "\rtracking_code\x18\x05 \x01(\tR\ftrackingCode\x12\x1f\n" + + "\veffect_kind\x18\x06 \x01(\tR\n" + + "effectKind\x12#\n" + + "\revent_version\x18\a \x01(\rR\feventVersion\x121\n" + + "\aentries\x18\b \x03(\v2\x17.ledger.v1.JournalEntryR\aentries\x128\n" + + "\x16reversal_of_journal_id\x18\t \x01(\tH\x00R\x13reversalOfJournalId\x88\x01\x01\x12;\n" + + "\voccurred_at\x18\n" + + " \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "occurredAt\x12;\n" + + "\vrecorded_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "recordedAt\x12%\n" + + "\x0ecorrelation_id\x18\f \x01(\tR\rcorrelationId\x12\x19\n" + + "\bactor_id\x18\r \x01(\tR\aactorId\x12>\n" + + "\n" + + "blockchain\x18\x0e \x01(\v2\x1e.ledger.v1.BlockchainReferenceR\n" + + "blockchain\x12<\n" + + "\bmetadata\x18\x0f \x03(\v2 .ledger.v1.Journal.MetadataEntryR\bmetadata\x12!\n" + + "\fpayload_hash\x18\x10 \x01(\tR\vpayloadHash\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x19\n" + + "\x17_reversal_of_journal_id\"\xd4\x05\n" + + "\x14AppendJournalRequest\x12%\n" + + "\x0esource_service\x18\x01 \x01(\tR\rsourceService\x12'\n" + + "\x0fidempotency_key\x18\x02 \x01(\tR\x0eidempotencyKey\x122\n" + + "\x15source_transaction_id\x18\x03 \x01(\tR\x13sourceTransactionId\x12#\n" + + "\rtracking_code\x18\x04 \x01(\tR\ftrackingCode\x12\x1f\n" + + "\veffect_kind\x18\x05 \x01(\tR\n" + + "effectKind\x12#\n" + + "\revent_version\x18\x06 \x01(\rR\feventVersion\x121\n" + + "\aentries\x18\a \x03(\v2\x17.ledger.v1.JournalEntryR\aentries\x128\n" + + "\x16reversal_of_journal_id\x18\b \x01(\tH\x00R\x13reversalOfJournalId\x88\x01\x01\x12;\n" + + "\voccurred_at\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "occurredAt\x12%\n" + + "\x0ecorrelation_id\x18\n" + + " \x01(\tR\rcorrelationId\x12\x19\n" + + "\bactor_id\x18\v \x01(\tR\aactorId\x12>\n" + + "\n" + + "blockchain\x18\f \x01(\v2\x1e.ledger.v1.BlockchainReferenceR\n" + + "blockchain\x12I\n" + + "\bmetadata\x18\r \x03(\v2-.ledger.v1.AppendJournalRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01B\x19\n" + + "\x17_reversal_of_journal_id\"n\n" + + "\x15AppendJournalResponse\x12,\n" + + "\ajournal\x18\x01 \x01(\v2\x12.ledger.v1.JournalR\ajournal\x12'\n" + + "\x0falready_existed\x18\x02 \x01(\bR\x0ealreadyExisted\"\xb4\x05\n" + + "\x1dAppendTransactionEventRequest\x12%\n" + + "\x0esource_service\x18\x01 \x01(\tR\rsourceService\x12'\n" + + "\x0fidempotency_key\x18\x02 \x01(\tR\x0eidempotencyKey\x122\n" + + "\x15source_transaction_id\x18\x03 \x01(\tR\x13sourceTransactionId\x12#\n" + + "\rtracking_code\x18\x04 \x01(\tR\ftrackingCode\x12#\n" + + "\revent_version\x18\x05 \x01(\rR\feventVersion\x121\n" + + "\x05state\x18\x06 \x01(\x0e2\x1b.ledger.v1.TransactionStateR\x05state\x12\x1d\n" + + "\n" + + "error_code\x18\a \x01(\tR\terrorCode\x12#\n" + + "\rerror_message\x18\b \x01(\tR\ferrorMessage\x12;\n" + + "\voccurred_at\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "occurredAt\x12%\n" + + "\x0ecorrelation_id\x18\n" + + " \x01(\tR\rcorrelationId\x12\x19\n" + + "\bactor_id\x18\v \x01(\tR\aactorId\x12>\n" + + "\n" + + "blockchain\x18\f \x01(\v2\x1e.ledger.v1.BlockchainReferenceR\n" + + "blockchain\x12R\n" + + "\bmetadata\x18\r \x03(\v26.ledger.v1.AppendTransactionEventRequest.MetadataEntryR\bmetadata\x1a;\n" + + "\rMetadataEntry\x12\x10\n" + + "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" + + "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\xcd\x01\n" + + "\x10TransactionEvent\x12\x19\n" + + "\bevent_id\x18\x01 \x01(\tR\aeventId\x12>\n" + + "\x05event\x18\x02 \x01(\v2(.ledger.v1.AppendTransactionEventRequestR\x05event\x12;\n" + + "\vrecorded_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "recordedAt\x12!\n" + + "\fpayload_hash\x18\x04 \x01(\tR\vpayloadHash\"|\n" + + "\x1eAppendTransactionEventResponse\x121\n" + + "\x05event\x18\x01 \x01(\v2\x1b.ledger.v1.TransactionEventR\x05event\x12'\n" + + "\x0falready_existed\x18\x02 \x01(\bR\x0ealreadyExisted\"i\n" + + "\x11GetJournalRequest\x12\x1f\n" + + "\n" + + "journal_id\x18\x01 \x01(\tH\x00R\tjournalId\x12)\n" + + "\x0fidempotency_key\x18\x02 \x01(\tH\x00R\x0eidempotencyKeyB\b\n" + + "\x06lookup\"\xc3\x02\n" + + "\x12ListEntriesRequest\x12:\n" + + "\aaccount\x18\x01 \x01(\v2\x1b.ledger.v1.AccountReferenceH\x00R\aaccount\x88\x01\x01\x12\x1e\n" + + "\basset_id\x18\x02 \x01(\x03H\x01R\aassetId\x88\x01\x01\x12?\n" + + "\rrecorded_from\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\frecordedFrom\x12;\n" + + "\vrecorded_to\x18\x04 \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "recordedTo\x12\x1b\n" + + "\tpage_size\x18\x05 \x01(\rR\bpageSize\x12\x1d\n" + + "\n" + + "page_token\x18\x06 \x01(\tR\tpageTokenB\n" + + "\n" + + "\b_accountB\v\n" + + "\t_asset_id\"m\n" + + "\x13ListEntriesResponse\x12.\n" + + "\bjournals\x18\x01 \x03(\v2\x12.ledger.v1.JournalR\bjournals\x12&\n" + + "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"{\n" + + "\x11GetBalanceRequest\x125\n" + + "\aaccount\x18\x01 \x01(\v2\x1b.ledger.v1.AccountReferenceR\aaccount\x12/\n" + + "\x05as_of\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x04asOf\"\x96\x01\n" + + "\x12GetBalanceResponse\x125\n" + + "\aaccount\x18\x01 \x01(\v2\x1b.ledger.v1.AccountReferenceR\aaccount\x12\x18\n" + + "\abalance\x18\x02 \x01(\tR\abalance\x12/\n" + + "\x05as_of\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\x04asOf\"T\n" + + "\x15ReplayJournalsRequest\x12;\n" + + "\bjournals\x18\x01 \x03(\v2\x1f.ledger.v1.AppendJournalRequestR\bjournals\"\x95\x01\n" + + "\x13ReplayJournalResult\x12'\n" + + "\x0fidempotency_key\x18\x01 \x01(\tR\x0eidempotencyKey\x12,\n" + + "\ajournal\x18\x02 \x01(\v2\x12.ledger.v1.JournalR\ajournal\x12'\n" + + "\x0falready_existed\x18\x03 \x01(\bR\x0ealreadyExisted\"R\n" + + "\x16ReplayJournalsResponse\x128\n" + + "\aresults\x18\x01 \x03(\v2\x1e.ledger.v1.ReplayJournalResultR\aresults\"Q\n" + + "\x0eHealthResponse\x12\x18\n" + + "\aserving\x18\x01 \x01(\bR\aserving\x12%\n" + + "\x0edatabase_ready\x18\x02 \x01(\bR\rdatabaseReady*\x9a\x02\n" + + "\fAccountClass\x12\x1d\n" + + "\x19ACCOUNT_CLASS_UNSPECIFIED\x10\x00\x12 \n" + + "\x1cACCOUNT_CLASS_USER_AVAILABLE\x10\x01\x12\x1d\n" + + "\x19ACCOUNT_CLASS_USER_FROZEN\x10\x02\x12%\n" + + "!ACCOUNT_CLASS_EXTERNAL_BLOCKCHAIN\x10\x03\x12\x1a\n" + + "\x16ACCOUNT_CLASS_TREASURY\x10\x04\x12!\n" + + "\x1dACCOUNT_CLASS_MARKET_CLEARING\x10\x05\x12\x1e\n" + + "\x1aACCOUNT_CLASS_IPG_CLEARING\x10\x06\x12$\n" + + " ACCOUNT_CLASS_COMMISSION_REVENUE\x10\a*\x85\x02\n" + + "\x10TransactionState\x12!\n" + + "\x1dTRANSACTION_STATE_UNSPECIFIED\x10\x00\x12\x1d\n" + + "\x19TRANSACTION_STATE_CREATED\x10\x01\x12)\n" + + "%TRANSACTION_STATE_PENDING_TRANSACTION\x10\x02\x12#\n" + + "\x1fTRANSACTION_STATE_PENDING_ADMIN\x10\x03\x12 \n" + + "\x1cTRANSACTION_STATE_SUCCESSFUL\x10\x04\x12\x1c\n" + + "\x18TRANSACTION_STATE_FAILED\x10\x05\x12\x1f\n" + + "\x1bTRANSACTION_STATE_SUSPENDED\x10\x06By\n" + + "\rcom.ledger.v1B\bMsgProtoP\x01Z\x19gl/gen/ledger/v1;ledgerv1\xa2\x02\x03LXX\xaa\x02\tLedger.V1\xca\x02\tLedger\\V1\xe2\x02\x15Ledger\\V1\\GPBMetadata\xea\x02\n" + + "Ledger::V1b\x06proto3" + +var ( + file_ledger_v1_msg_proto_rawDescOnce sync.Once + file_ledger_v1_msg_proto_rawDescData []byte +) + +func file_ledger_v1_msg_proto_rawDescGZIP() []byte { + file_ledger_v1_msg_proto_rawDescOnce.Do(func() { + file_ledger_v1_msg_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ledger_v1_msg_proto_rawDesc), len(file_ledger_v1_msg_proto_rawDesc))) + }) + return file_ledger_v1_msg_proto_rawDescData +} + +var file_ledger_v1_msg_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_ledger_v1_msg_proto_msgTypes = make([]protoimpl.MessageInfo, 21) +var file_ledger_v1_msg_proto_goTypes = []any{ + (AccountClass)(0), // 0: ledger.v1.AccountClass + (TransactionState)(0), // 1: ledger.v1.TransactionState + (*AccountReference)(nil), // 2: ledger.v1.AccountReference + (*JournalEntry)(nil), // 3: ledger.v1.JournalEntry + (*BlockchainReference)(nil), // 4: ledger.v1.BlockchainReference + (*Journal)(nil), // 5: ledger.v1.Journal + (*AppendJournalRequest)(nil), // 6: ledger.v1.AppendJournalRequest + (*AppendJournalResponse)(nil), // 7: ledger.v1.AppendJournalResponse + (*AppendTransactionEventRequest)(nil), // 8: ledger.v1.AppendTransactionEventRequest + (*TransactionEvent)(nil), // 9: ledger.v1.TransactionEvent + (*AppendTransactionEventResponse)(nil), // 10: ledger.v1.AppendTransactionEventResponse + (*GetJournalRequest)(nil), // 11: ledger.v1.GetJournalRequest + (*ListEntriesRequest)(nil), // 12: ledger.v1.ListEntriesRequest + (*ListEntriesResponse)(nil), // 13: ledger.v1.ListEntriesResponse + (*GetBalanceRequest)(nil), // 14: ledger.v1.GetBalanceRequest + (*GetBalanceResponse)(nil), // 15: ledger.v1.GetBalanceResponse + (*ReplayJournalsRequest)(nil), // 16: ledger.v1.ReplayJournalsRequest + (*ReplayJournalResult)(nil), // 17: ledger.v1.ReplayJournalResult + (*ReplayJournalsResponse)(nil), // 18: ledger.v1.ReplayJournalsResponse + (*HealthResponse)(nil), // 19: ledger.v1.HealthResponse + nil, // 20: ledger.v1.Journal.MetadataEntry + nil, // 21: ledger.v1.AppendJournalRequest.MetadataEntry + nil, // 22: ledger.v1.AppendTransactionEventRequest.MetadataEntry + (*timestamppb.Timestamp)(nil), // 23: google.protobuf.Timestamp +} +var file_ledger_v1_msg_proto_depIdxs = []int32{ + 0, // 0: ledger.v1.AccountReference.account_class:type_name -> ledger.v1.AccountClass + 2, // 1: ledger.v1.JournalEntry.account:type_name -> ledger.v1.AccountReference + 3, // 2: ledger.v1.Journal.entries:type_name -> ledger.v1.JournalEntry + 23, // 3: ledger.v1.Journal.occurred_at:type_name -> google.protobuf.Timestamp + 23, // 4: ledger.v1.Journal.recorded_at:type_name -> google.protobuf.Timestamp + 4, // 5: ledger.v1.Journal.blockchain:type_name -> ledger.v1.BlockchainReference + 20, // 6: ledger.v1.Journal.metadata:type_name -> ledger.v1.Journal.MetadataEntry + 3, // 7: ledger.v1.AppendJournalRequest.entries:type_name -> ledger.v1.JournalEntry + 23, // 8: ledger.v1.AppendJournalRequest.occurred_at:type_name -> google.protobuf.Timestamp + 4, // 9: ledger.v1.AppendJournalRequest.blockchain:type_name -> ledger.v1.BlockchainReference + 21, // 10: ledger.v1.AppendJournalRequest.metadata:type_name -> ledger.v1.AppendJournalRequest.MetadataEntry + 5, // 11: ledger.v1.AppendJournalResponse.journal:type_name -> ledger.v1.Journal + 1, // 12: ledger.v1.AppendTransactionEventRequest.state:type_name -> ledger.v1.TransactionState + 23, // 13: ledger.v1.AppendTransactionEventRequest.occurred_at:type_name -> google.protobuf.Timestamp + 4, // 14: ledger.v1.AppendTransactionEventRequest.blockchain:type_name -> ledger.v1.BlockchainReference + 22, // 15: ledger.v1.AppendTransactionEventRequest.metadata:type_name -> ledger.v1.AppendTransactionEventRequest.MetadataEntry + 8, // 16: ledger.v1.TransactionEvent.event:type_name -> ledger.v1.AppendTransactionEventRequest + 23, // 17: ledger.v1.TransactionEvent.recorded_at:type_name -> google.protobuf.Timestamp + 9, // 18: ledger.v1.AppendTransactionEventResponse.event:type_name -> ledger.v1.TransactionEvent + 2, // 19: ledger.v1.ListEntriesRequest.account:type_name -> ledger.v1.AccountReference + 23, // 20: ledger.v1.ListEntriesRequest.recorded_from:type_name -> google.protobuf.Timestamp + 23, // 21: ledger.v1.ListEntriesRequest.recorded_to:type_name -> google.protobuf.Timestamp + 5, // 22: ledger.v1.ListEntriesResponse.journals:type_name -> ledger.v1.Journal + 2, // 23: ledger.v1.GetBalanceRequest.account:type_name -> ledger.v1.AccountReference + 23, // 24: ledger.v1.GetBalanceRequest.as_of:type_name -> google.protobuf.Timestamp + 2, // 25: ledger.v1.GetBalanceResponse.account:type_name -> ledger.v1.AccountReference + 23, // 26: ledger.v1.GetBalanceResponse.as_of:type_name -> google.protobuf.Timestamp + 6, // 27: ledger.v1.ReplayJournalsRequest.journals:type_name -> ledger.v1.AppendJournalRequest + 5, // 28: ledger.v1.ReplayJournalResult.journal:type_name -> ledger.v1.Journal + 17, // 29: ledger.v1.ReplayJournalsResponse.results:type_name -> ledger.v1.ReplayJournalResult + 30, // [30:30] is the sub-list for method output_type + 30, // [30:30] is the sub-list for method input_type + 30, // [30:30] is the sub-list for extension type_name + 30, // [30:30] is the sub-list for extension extendee + 0, // [0:30] is the sub-list for field type_name +} + +func init() { file_ledger_v1_msg_proto_init() } +func file_ledger_v1_msg_proto_init() { + if File_ledger_v1_msg_proto != nil { + return + } + file_ledger_v1_msg_proto_msgTypes[3].OneofWrappers = []any{} + file_ledger_v1_msg_proto_msgTypes[4].OneofWrappers = []any{} + file_ledger_v1_msg_proto_msgTypes[9].OneofWrappers = []any{ + (*GetJournalRequest_JournalId)(nil), + (*GetJournalRequest_IdempotencyKey)(nil), + } + file_ledger_v1_msg_proto_msgTypes[10].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_ledger_v1_msg_proto_rawDesc), len(file_ledger_v1_msg_proto_rawDesc)), + NumEnums: 2, + NumMessages: 21, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_ledger_v1_msg_proto_goTypes, + DependencyIndexes: file_ledger_v1_msg_proto_depIdxs, + EnumInfos: file_ledger_v1_msg_proto_enumTypes, + MessageInfos: file_ledger_v1_msg_proto_msgTypes, + }.Build() + File_ledger_v1_msg_proto = out.File + file_ledger_v1_msg_proto_goTypes = nil + file_ledger_v1_msg_proto_depIdxs = nil +} diff --git a/gen/ledger/v1/srv.pb.go b/gen/ledger/v1/srv.pb.go new file mode 100644 index 0000000..3f90d43 --- /dev/null +++ b/gen/ledger/v1/srv.pb.go @@ -0,0 +1,102 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: ledger/v1/srv.proto + +package ledgerv1 + +import ( + v1 "gl/gen/base/v1" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +var File_ledger_v1_srv_proto protoreflect.FileDescriptor + +const file_ledger_v1_srv_proto_rawDesc = "" + + "\n" + + "\x13ledger/v1/srv.proto\x12\tledger.v1\x1a\x11base/v1/msg.proto\x1a\x13ledger/v1/msg.proto2\xbe\x04\n" + + "\x14GeneralLedgerService\x123\n" + + "\x06Health\x12\x0e.base.v1.Empty\x1a\x19.ledger.v1.HealthResponse\x12R\n" + + "\rAppendJournal\x12\x1f.ledger.v1.AppendJournalRequest\x1a .ledger.v1.AppendJournalResponse\x12m\n" + + "\x16AppendTransactionEvent\x12(.ledger.v1.AppendTransactionEventRequest\x1a).ledger.v1.AppendTransactionEventResponse\x12>\n" + + "\n" + + "GetJournal\x12\x1c.ledger.v1.GetJournalRequest\x1a\x12.ledger.v1.Journal\x12L\n" + + "\vListEntries\x12\x1d.ledger.v1.ListEntriesRequest\x1a\x1e.ledger.v1.ListEntriesResponse\x12I\n" + + "\n" + + "GetBalance\x12\x1c.ledger.v1.GetBalanceRequest\x1a\x1d.ledger.v1.GetBalanceResponse\x12U\n" + + "\x0eReplayJournals\x12 .ledger.v1.ReplayJournalsRequest\x1a!.ledger.v1.ReplayJournalsResponseBy\n" + + "\rcom.ledger.v1B\bSrvProtoP\x01Z\x19gl/gen/ledger/v1;ledgerv1\xa2\x02\x03LXX\xaa\x02\tLedger.V1\xca\x02\tLedger\\V1\xe2\x02\x15Ledger\\V1\\GPBMetadata\xea\x02\n" + + "Ledger::V1b\x06proto3" + +var file_ledger_v1_srv_proto_goTypes = []any{ + (*v1.Empty)(nil), // 0: base.v1.Empty + (*AppendJournalRequest)(nil), // 1: ledger.v1.AppendJournalRequest + (*AppendTransactionEventRequest)(nil), // 2: ledger.v1.AppendTransactionEventRequest + (*GetJournalRequest)(nil), // 3: ledger.v1.GetJournalRequest + (*ListEntriesRequest)(nil), // 4: ledger.v1.ListEntriesRequest + (*GetBalanceRequest)(nil), // 5: ledger.v1.GetBalanceRequest + (*ReplayJournalsRequest)(nil), // 6: ledger.v1.ReplayJournalsRequest + (*HealthResponse)(nil), // 7: ledger.v1.HealthResponse + (*AppendJournalResponse)(nil), // 8: ledger.v1.AppendJournalResponse + (*AppendTransactionEventResponse)(nil), // 9: ledger.v1.AppendTransactionEventResponse + (*Journal)(nil), // 10: ledger.v1.Journal + (*ListEntriesResponse)(nil), // 11: ledger.v1.ListEntriesResponse + (*GetBalanceResponse)(nil), // 12: ledger.v1.GetBalanceResponse + (*ReplayJournalsResponse)(nil), // 13: ledger.v1.ReplayJournalsResponse +} +var file_ledger_v1_srv_proto_depIdxs = []int32{ + 0, // 0: ledger.v1.GeneralLedgerService.Health:input_type -> base.v1.Empty + 1, // 1: ledger.v1.GeneralLedgerService.AppendJournal:input_type -> ledger.v1.AppendJournalRequest + 2, // 2: ledger.v1.GeneralLedgerService.AppendTransactionEvent:input_type -> ledger.v1.AppendTransactionEventRequest + 3, // 3: ledger.v1.GeneralLedgerService.GetJournal:input_type -> ledger.v1.GetJournalRequest + 4, // 4: ledger.v1.GeneralLedgerService.ListEntries:input_type -> ledger.v1.ListEntriesRequest + 5, // 5: ledger.v1.GeneralLedgerService.GetBalance:input_type -> ledger.v1.GetBalanceRequest + 6, // 6: ledger.v1.GeneralLedgerService.ReplayJournals:input_type -> ledger.v1.ReplayJournalsRequest + 7, // 7: ledger.v1.GeneralLedgerService.Health:output_type -> ledger.v1.HealthResponse + 8, // 8: ledger.v1.GeneralLedgerService.AppendJournal:output_type -> ledger.v1.AppendJournalResponse + 9, // 9: ledger.v1.GeneralLedgerService.AppendTransactionEvent:output_type -> ledger.v1.AppendTransactionEventResponse + 10, // 10: ledger.v1.GeneralLedgerService.GetJournal:output_type -> ledger.v1.Journal + 11, // 11: ledger.v1.GeneralLedgerService.ListEntries:output_type -> ledger.v1.ListEntriesResponse + 12, // 12: ledger.v1.GeneralLedgerService.GetBalance:output_type -> ledger.v1.GetBalanceResponse + 13, // 13: ledger.v1.GeneralLedgerService.ReplayJournals:output_type -> ledger.v1.ReplayJournalsResponse + 7, // [7:14] is the sub-list for method output_type + 0, // [0:7] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_ledger_v1_srv_proto_init() } +func file_ledger_v1_srv_proto_init() { + if File_ledger_v1_srv_proto != nil { + return + } + file_ledger_v1_msg_proto_init() + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_ledger_v1_srv_proto_rawDesc), len(file_ledger_v1_srv_proto_rawDesc)), + NumEnums: 0, + NumMessages: 0, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_ledger_v1_srv_proto_goTypes, + DependencyIndexes: file_ledger_v1_srv_proto_depIdxs, + }.Build() + File_ledger_v1_srv_proto = out.File + file_ledger_v1_srv_proto_goTypes = nil + file_ledger_v1_srv_proto_depIdxs = nil +} diff --git a/gen/ledger/v1/srv_grpc.pb.go b/gen/ledger/v1/srv_grpc.pb.go new file mode 100644 index 0000000..e16298a --- /dev/null +++ b/gen/ledger/v1/srv_grpc.pb.go @@ -0,0 +1,348 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.2 +// - protoc (unknown) +// source: ledger/v1/srv.proto + +package ledgerv1 + +import ( + context "context" + v1 "gl/gen/base/v1" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +// Requires gRPC-Go v1.64.0 or later. +const _ = grpc.SupportPackageIsVersion9 + +const ( + GeneralLedgerService_Health_FullMethodName = "/ledger.v1.GeneralLedgerService/Health" + GeneralLedgerService_AppendJournal_FullMethodName = "/ledger.v1.GeneralLedgerService/AppendJournal" + GeneralLedgerService_AppendTransactionEvent_FullMethodName = "/ledger.v1.GeneralLedgerService/AppendTransactionEvent" + GeneralLedgerService_GetJournal_FullMethodName = "/ledger.v1.GeneralLedgerService/GetJournal" + GeneralLedgerService_ListEntries_FullMethodName = "/ledger.v1.GeneralLedgerService/ListEntries" + GeneralLedgerService_GetBalance_FullMethodName = "/ledger.v1.GeneralLedgerService/GetBalance" + GeneralLedgerService_ReplayJournals_FullMethodName = "/ledger.v1.GeneralLedgerService/ReplayJournals" +) + +// GeneralLedgerServiceClient is the client API for GeneralLedgerService service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. +type GeneralLedgerServiceClient interface { + Health(ctx context.Context, in *v1.Empty, opts ...grpc.CallOption) (*HealthResponse, error) + AppendJournal(ctx context.Context, in *AppendJournalRequest, opts ...grpc.CallOption) (*AppendJournalResponse, error) + AppendTransactionEvent(ctx context.Context, in *AppendTransactionEventRequest, opts ...grpc.CallOption) (*AppendTransactionEventResponse, error) + GetJournal(ctx context.Context, in *GetJournalRequest, opts ...grpc.CallOption) (*Journal, error) + ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (*ListEntriesResponse, error) + GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error) + ReplayJournals(ctx context.Context, in *ReplayJournalsRequest, opts ...grpc.CallOption) (*ReplayJournalsResponse, error) +} + +type generalLedgerServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewGeneralLedgerServiceClient(cc grpc.ClientConnInterface) GeneralLedgerServiceClient { + return &generalLedgerServiceClient{cc} +} + +func (c *generalLedgerServiceClient) Health(ctx context.Context, in *v1.Empty, opts ...grpc.CallOption) (*HealthResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(HealthResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_Health_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) AppendJournal(ctx context.Context, in *AppendJournalRequest, opts ...grpc.CallOption) (*AppendJournalResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AppendJournalResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_AppendJournal_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) AppendTransactionEvent(ctx context.Context, in *AppendTransactionEventRequest, opts ...grpc.CallOption) (*AppendTransactionEventResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AppendTransactionEventResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_AppendTransactionEvent_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) GetJournal(ctx context.Context, in *GetJournalRequest, opts ...grpc.CallOption) (*Journal, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(Journal) + err := c.cc.Invoke(ctx, GeneralLedgerService_GetJournal_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) ListEntries(ctx context.Context, in *ListEntriesRequest, opts ...grpc.CallOption) (*ListEntriesResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListEntriesResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_ListEntries_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetBalanceResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_GetBalance_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *generalLedgerServiceClient) ReplayJournals(ctx context.Context, in *ReplayJournalsRequest, opts ...grpc.CallOption) (*ReplayJournalsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ReplayJournalsResponse) + err := c.cc.Invoke(ctx, GeneralLedgerService_ReplayJournals_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// GeneralLedgerServiceServer is the server API for GeneralLedgerService service. +// All implementations should embed UnimplementedGeneralLedgerServiceServer +// for forward compatibility. +type GeneralLedgerServiceServer interface { + Health(context.Context, *v1.Empty) (*HealthResponse, error) + AppendJournal(context.Context, *AppendJournalRequest) (*AppendJournalResponse, error) + AppendTransactionEvent(context.Context, *AppendTransactionEventRequest) (*AppendTransactionEventResponse, error) + GetJournal(context.Context, *GetJournalRequest) (*Journal, error) + ListEntries(context.Context, *ListEntriesRequest) (*ListEntriesResponse, error) + GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) + ReplayJournals(context.Context, *ReplayJournalsRequest) (*ReplayJournalsResponse, error) +} + +// UnimplementedGeneralLedgerServiceServer should be embedded to have +// forward compatible implementations. +// +// NOTE: this should be embedded by value instead of pointer to avoid a nil +// pointer dereference when methods are called. +type UnimplementedGeneralLedgerServiceServer struct{} + +func (UnimplementedGeneralLedgerServiceServer) Health(context.Context, *v1.Empty) (*HealthResponse, error) { + return nil, status.Error(codes.Unimplemented, "method Health not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) AppendJournal(context.Context, *AppendJournalRequest) (*AppendJournalResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AppendJournal not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) AppendTransactionEvent(context.Context, *AppendTransactionEventRequest) (*AppendTransactionEventResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AppendTransactionEvent not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) GetJournal(context.Context, *GetJournalRequest) (*Journal, error) { + return nil, status.Error(codes.Unimplemented, "method GetJournal not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) ListEntries(context.Context, *ListEntriesRequest) (*ListEntriesResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListEntries not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetBalance not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) ReplayJournals(context.Context, *ReplayJournalsRequest) (*ReplayJournalsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ReplayJournals not implemented") +} +func (UnimplementedGeneralLedgerServiceServer) testEmbeddedByValue() {} + +// UnsafeGeneralLedgerServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to GeneralLedgerServiceServer will +// result in compilation errors. +type UnsafeGeneralLedgerServiceServer interface { + mustEmbedUnimplementedGeneralLedgerServiceServer() +} + +func RegisterGeneralLedgerServiceServer(s grpc.ServiceRegistrar, srv GeneralLedgerServiceServer) { + // If the following call panics, it indicates UnimplementedGeneralLedgerServiceServer was + // embedded by pointer and is nil. This will cause panics if an + // unimplemented method is ever invoked, so we test this at initialization + // time to prevent it from happening at runtime later due to I/O. + if t, ok := srv.(interface{ testEmbeddedByValue() }); ok { + t.testEmbeddedByValue() + } + s.RegisterService(&GeneralLedgerService_ServiceDesc, srv) +} + +func _GeneralLedgerService_Health_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(v1.Empty) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).Health(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_Health_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).Health(ctx, req.(*v1.Empty)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_AppendJournal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppendJournalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).AppendJournal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_AppendJournal_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).AppendJournal(ctx, req.(*AppendJournalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_AppendTransactionEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AppendTransactionEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).AppendTransactionEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_AppendTransactionEvent_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).AppendTransactionEvent(ctx, req.(*AppendTransactionEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_GetJournal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetJournalRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).GetJournal(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_GetJournal_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).GetJournal(ctx, req.(*GetJournalRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_ListEntries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListEntriesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).ListEntries(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_ListEntries_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).ListEntries(ctx, req.(*ListEntriesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_GetBalance_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetBalanceRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).GetBalance(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_GetBalance_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).GetBalance(ctx, req.(*GetBalanceRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GeneralLedgerService_ReplayJournals_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ReplayJournalsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GeneralLedgerServiceServer).ReplayJournals(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: GeneralLedgerService_ReplayJournals_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GeneralLedgerServiceServer).ReplayJournals(ctx, req.(*ReplayJournalsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// GeneralLedgerService_ServiceDesc is the grpc.ServiceDesc for GeneralLedgerService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var GeneralLedgerService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "ledger.v1.GeneralLedgerService", + HandlerType: (*GeneralLedgerServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "Health", + Handler: _GeneralLedgerService_Health_Handler, + }, + { + MethodName: "AppendJournal", + Handler: _GeneralLedgerService_AppendJournal_Handler, + }, + { + MethodName: "AppendTransactionEvent", + Handler: _GeneralLedgerService_AppendTransactionEvent_Handler, + }, + { + MethodName: "GetJournal", + Handler: _GeneralLedgerService_GetJournal_Handler, + }, + { + MethodName: "ListEntries", + Handler: _GeneralLedgerService_ListEntries_Handler, + }, + { + MethodName: "GetBalance", + Handler: _GeneralLedgerService_GetBalance_Handler, + }, + { + MethodName: "ReplayJournals", + Handler: _GeneralLedgerService_ReplayJournals_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "ledger/v1/srv.proto", +} diff --git a/gl.cfg.toml b/gl.cfg.toml new file mode 100644 index 0000000..c6d5d29 --- /dev/null +++ b/gl.cfg.toml @@ -0,0 +1,14 @@ +environment = "local" + +[grpc] +host = "0.0.0.0" +port = 8500 +shutdown-timeout = "10s" + +[database] +host = "127.0.0.1" +port = 5432 +name = "gl_db" +user = "postgres" +password = "" +ssl-mode = "disable" diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..764ea76 --- /dev/null +++ b/go.mod @@ -0,0 +1,24 @@ +module gl + +go 1.24 + +require ( + github.com/knadh/koanf/parsers/toml v0.1.0 + github.com/knadh/koanf/providers/file v1.2.1 + github.com/knadh/koanf/v2 v2.3.4 + google.golang.org/grpc v1.67.1 + google.golang.org/protobuf v1.36.6 +) + +require ( + github.com/fsnotify/fsnotify v1.9.0 // indirect + github.com/go-viper/mapstructure/v2 v2.4.0 // indirect + github.com/knadh/koanf/maps v0.1.2 // indirect + github.com/mitchellh/copystructure v1.2.0 // indirect + github.com/mitchellh/reflectwalk v1.0.2 // indirect + github.com/pelletier/go-toml v1.9.5 // indirect + golang.org/x/net v0.28.0 // indirect + golang.org/x/sys v0.32.0 // indirect + golang.org/x/text v0.17.0 // indirect + google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..5ea5e05 --- /dev/null +++ b/go.sum @@ -0,0 +1,40 @@ +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k= +github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= +github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs= +github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/knadh/koanf/maps v0.1.2 h1:RBfmAW5CnZT+PJ1CVc1QSJKf4Xu9kxfQgYVQSu8hpbo= +github.com/knadh/koanf/maps v0.1.2/go.mod h1:npD/QZY3V6ghQDdcQzl1W4ICNVTkohC8E73eI2xW4yI= +github.com/knadh/koanf/parsers/toml v0.1.0 h1:S2hLqS4TgWZYj4/7mI5m1CQQcWurxUz6ODgOub/6LCI= +github.com/knadh/koanf/parsers/toml v0.1.0/go.mod h1:yUprhq6eo3GbyVXFFMdbfZSo928ksS+uo0FFqNMnO18= +github.com/knadh/koanf/providers/file v1.2.1 h1:bEWbtQwYrA+W2DtdBrQWyXqJaJSG3KrP3AESOJYp9wM= +github.com/knadh/koanf/providers/file v1.2.1/go.mod h1:bp1PM5f83Q+TOUu10J/0ApLBd9uIzg+n9UgthfY+nRA= +github.com/knadh/koanf/v2 v2.3.4 h1:fnynNSDlujWE+v83hAp8wKr/cdoxHLO0629SN+U8Urc= +github.com/knadh/koanf/v2 v2.3.4/go.mod h1:gRb40VRAbd4iJMYYD5IxZ6hfuopFcXBpc9bbQpZwo28= +github.com/mitchellh/copystructure v1.2.0 h1:vpKXTN4ewci03Vljg/q9QvCGUDttBOGBIa15WveJJGw= +github.com/mitchellh/copystructure v1.2.0/go.mod h1:qLl+cE2AmVv+CoeAwDPye/v+N2HKCj9FbZEVFJRxO9s= +github.com/mitchellh/reflectwalk v1.0.2 h1:G2LzWKi524PWgd3mLHV8Y5k7s6XUvT0Gef6zxSIeXaQ= +github.com/mitchellh/reflectwalk v1.0.2/go.mod h1:mSTlrgnPZtwu0c4WaC2kGObEpuNDbx0jmZXqmk4esnw= +github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= +github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk= +github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= +golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= +golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20= +golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc= +golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142 h1:e7S5W7MGGLaSu8j3YjdezkZ+m1/Nm0uRVRMEMGk26Xs= +google.golang.org/genproto/googleapis/rpc v0.0.0-20240814211410-ddb44dafa142/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= +google.golang.org/grpc v1.67.1 h1:zWnc1Vrcno+lHZCOofnIMvycFcc0QRGIzm9dhnDX68E= +google.golang.org/grpc v1.67.1/go.mod h1:1gLDyUQU7CTLJI90u3nXZ9ekeghjeM7pTDZlqFNg2AA= +google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY= +google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/infrastructure/config/config.go b/infrastructure/config/config.go new file mode 100644 index 0000000..ab96ffd --- /dev/null +++ b/infrastructure/config/config.go @@ -0,0 +1,81 @@ +// Package config owns GL configuration loading and validation. +package config + +import ( + "fmt" + "time" + + "github.com/knadh/koanf/parsers/toml" + "github.com/knadh/koanf/providers/file" + "github.com/knadh/koanf/v2" +) + +type Config struct { + Environment string `koanf:"environment"` + GRPC GRPCConfig `koanf:"grpc"` + Database DatabaseConfig `koanf:"database"` +} + +type GRPCConfig struct { + Host string `koanf:"host"` + Port int `koanf:"port"` + ShutdownTimeout time.Duration `koanf:"shutdown-timeout"` +} + +type DatabaseConfig struct { + Host string `koanf:"host"` + Port int `koanf:"port"` + Name string `koanf:"name"` + User string `koanf:"user"` + Password string `koanf:"password"` + SSLMode string `koanf:"ssl-mode"` +} + +func Load(path string) (*Config, error) { + cfg := &Config{ + Environment: "local", + GRPC: GRPCConfig{ + Host: "0.0.0.0", + Port: 8500, + ShutdownTimeout: 10 * time.Second, + }, + Database: DatabaseConfig{ + Host: "127.0.0.1", + Port: 5432, + Name: "gl_db", + User: "postgres", + SSLMode: "disable", + }, + } + + k := koanf.New(".") + if err := k.Load(file.Provider(path), toml.Parser()); err != nil { + return nil, fmt.Errorf("load config: %w", err) + } + if err := k.Unmarshal("", cfg); err != nil { + return nil, fmt.Errorf("decode config: %w", err) + } + if err := cfg.Validate(); err != nil { + return nil, err + } + return cfg, nil +} + +func (c *Config) Validate() error { + if c.GRPC.Host == "" { + return fmt.Errorf("grpc host is required") + } + if c.GRPC.Port < 0 || c.GRPC.Port > 65535 { + return fmt.Errorf("grpc port must be between 0 and 65535") + } + if c.GRPC.ShutdownTimeout <= 0 { + return fmt.Errorf("grpc shutdown timeout must be positive") + } + if c.Database.Host == "" || c.Database.Name == "" || c.Database.User == "" { + return fmt.Errorf("database host, name, and user are required") + } + if c.Database.Port < 1 || c.Database.Port > 65535 { + return fmt.Errorf("database port must be between 1 and 65535") + } + return nil +} diff --git a/infrastructure/config/config_test.go b/infrastructure/config/config_test.go new file mode 100644 index 0000000..4d8b1e0 --- /dev/null +++ b/infrastructure/config/config_test.go @@ -0,0 +1,46 @@ +package config + +import ( + "os" + "path/filepath" + "testing" + "time" +) + +func TestLoadUsesDefaultsAndOverrides(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "gl.toml") + contents := []byte("[grpc]\nport = 0\nshutdown-timeout = \"3s\"\n") + if err := os.WriteFile(path, contents, 0o600); err != nil { + t.Fatal(err) + } + + cfg, err := Load(path) + if err != nil { + t.Fatal(err) + } + if cfg.GRPC.Port != 0 || cfg.GRPC.ShutdownTimeout != 3*time.Second { + t.Fatalf("unexpected grpc config: %+v", cfg.GRPC) + } + if cfg.Database.Name != "gl_db" || cfg.Database.Port != 5432 { + t.Fatalf("unexpected database defaults: %+v", cfg.Database) + } +} + +func TestLoadRejectsInvalidConfiguration(t *testing.T) { + dir := t.TempDir() + path := filepath.Join(dir, "gl.toml") + if err := os.WriteFile(path, []byte("[grpc]\nshutdown-timeout = \"0s\"\n"), 0o600); err != nil { + t.Fatal(err) + } + + if _, err := Load(path); err == nil { + t.Fatal("expected validation error") + } +} + +func TestLoadReturnsMissingFileError(t *testing.T) { + if _, err := Load(filepath.Join(t.TempDir(), "missing.toml")); err == nil { + t.Fatal("expected missing file error") + } +} diff --git a/interface/grpc/health.go b/interface/grpc/health.go new file mode 100644 index 0000000..f49e534 --- /dev/null +++ b/interface/grpc/health.go @@ -0,0 +1,26 @@ +package grpcadapter + +import ( + "context" + + "gl/application/health" + basev1 "gl/gen/base/v1" + ledgerv1 "gl/gen/ledger/v1" +) + +type HealthHandler struct { + ledgerv1.UnimplementedGeneralLedgerServiceServer + service *health.Service +} + +func NewHealthHandler(service *health.Service) *HealthHandler { + return &HealthHandler{service: service} +} + +func (h *HealthHandler) Health(ctx context.Context, _ *basev1.Empty) (*ledgerv1.HealthResponse, error) { + result := h.service.Check(ctx) + return &ledgerv1.HealthResponse{ + Serving: result.Serving, + DatabaseReady: result.DatabaseReady, + }, nil +} diff --git a/interface/grpc/health_test.go b/interface/grpc/health_test.go new file mode 100644 index 0000000..2707180 --- /dev/null +++ b/interface/grpc/health_test.go @@ -0,0 +1,19 @@ +package grpcadapter + +import ( + "context" + "testing" + + "gl/application/health" + basev1 "gl/gen/base/v1" +) + +func TestHealth(t *testing.T) { + response, err := NewHealthHandler(health.NewService(nil)).Health(context.Background(), &basev1.Empty{}) + if err != nil { + t.Fatal(err) + } + if !response.Serving || response.DatabaseReady { + t.Fatalf("unexpected response: %+v", response) + } +} diff --git a/interface/grpc/server.go b/interface/grpc/server.go new file mode 100644 index 0000000..bf45ca6 --- /dev/null +++ b/interface/grpc/server.go @@ -0,0 +1,69 @@ +package grpcadapter + +import ( + "context" + "errors" + "fmt" + "net" + "time" + + ledgerv1 "gl/gen/ledger/v1" + + "google.golang.org/grpc" + "google.golang.org/grpc/reflection" +) + +type ServerConfig struct { + Host string + Port int + ShutdownTimeout time.Duration +} + +func Run(ctx context.Context, cfg ServerConfig, handler ledgerv1.GeneralLedgerServiceServer) error { + listener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)) + if err != nil { + return fmt.Errorf("listen for grpc: %w", err) + } + return runWithListener(ctx, cfg.ShutdownTimeout, listener, handler) +} + +func runWithListener(ctx context.Context, shutdownTimeout time.Duration, listener net.Listener, handler ledgerv1.GeneralLedgerServiceServer) error { + defer listener.Close() + + server := grpc.NewServer() + ledgerv1.RegisterGeneralLedgerServiceServer(server, handler) + reflection.Register(server) + + serveErr := make(chan error, 1) + go func() { serveErr <- server.Serve(listener) }() + + select { + case err := <-serveErr: + if errors.Is(err, grpc.ErrServerStopped) { + return nil + } + return fmt.Errorf("serve grpc: %w", err) + case <-ctx.Done(): + } + + stopped := make(chan struct{}) + go func() { + server.GracefulStop() + close(stopped) + }() + + timer := time.NewTimer(shutdownTimeout) + defer timer.Stop() + select { + case <-stopped: + case <-timer.C: + server.Stop() + <-stopped + } + + err := <-serveErr + if err != nil && !errors.Is(err, grpc.ErrServerStopped) { + return fmt.Errorf("serve grpc: %w", err) + } + return nil +} diff --git a/interface/grpc/server_test.go b/interface/grpc/server_test.go new file mode 100644 index 0000000..fff9bc7 --- /dev/null +++ b/interface/grpc/server_test.go @@ -0,0 +1,26 @@ +package grpcadapter + +import ( + "context" + "testing" + "time" + + "gl/application/health" + + "google.golang.org/grpc/test/bufconn" +) + +func TestRunStopsWhenContextIsCancelled(t *testing.T) { + ctx, cancel := context.WithCancel(context.Background()) + cancel() + + err := runWithListener( + ctx, + time.Second, + bufconn.Listen(1024), + NewHealthHandler(health.NewService(nil)), + ) + if err != nil { + t.Fatal(err) + } +}