feat: user service

pkg/model/user/user.go

@@ -0,0 +1,188 @@
+// Package user defines the public typed command and response payloads exposed
+// at the authenticated Gateway -> User self-service boundary.
+package user
+
+import "time"
+
+const (
+	// MessageTypeGetMyAccount is the authenticated gateway message type used to
+	// read the current regular-user account aggregate.
+	MessageTypeGetMyAccount = "user.account.get"
+
+	// MessageTypeUpdateMyProfile is the authenticated gateway message type used
+	// to mutate self-service profile fields.
+	MessageTypeUpdateMyProfile = "user.profile.update"
+
+	// MessageTypeUpdateMySettings is the authenticated gateway message type used
+	// to mutate self-service settings fields.
+	MessageTypeUpdateMySettings = "user.settings.update"
+)
+
+// GetMyAccountRequest stores the authenticated self-service read request for
+// the current regular-user account aggregate.
+//
+// The request body is intentionally empty because gateway derives user
+// identity from the authenticated device session rather than from client
+// payload fields.
+type GetMyAccountRequest struct{}
+
+// UpdateMyProfileRequest stores the authenticated self-service profile
+// mutation request.
+type UpdateMyProfileRequest struct {
+	// RaceName stores the requested exact replacement race name.
+	RaceName string `json:"race_name"`
+}
+
+// UpdateMySettingsRequest stores the authenticated self-service settings
+// mutation request.
+type UpdateMySettingsRequest struct {
+	// PreferredLanguage stores the requested BCP 47 language tag.
+	PreferredLanguage string `json:"preferred_language"`
+
+	// TimeZone stores the requested IANA time-zone name.
+	TimeZone string `json:"time_zone"`
+}
+
+// ActorRef stores transport-ready audit actor metadata projected by User
+// Service.
+type ActorRef struct {
+	// Type stores the machine-readable actor type.
+	Type string `json:"type"`
+
+	// ID stores the optional stable actor identifier.
+	ID string `json:"id,omitempty"`
+}
+
+// EntitlementSnapshot stores the transport-ready current entitlement snapshot
+// of one account.
+type EntitlementSnapshot struct {
+	// PlanCode stores the effective entitlement plan code.
+	PlanCode string `json:"plan_code"`
+
+	// IsPaid reports whether the effective entitlement is currently paid.
+	IsPaid bool `json:"is_paid"`
+
+	// Source stores the machine-readable source that produced the snapshot.
+	Source string `json:"source"`
+
+	// Actor stores the audit actor metadata attached to the current snapshot.
+	Actor ActorRef `json:"actor"`
+
+	// ReasonCode stores the machine-readable reason attached to the snapshot.
+	ReasonCode string `json:"reason_code"`
+
+	// StartsAt stores when the effective state started.
+	StartsAt time.Time `json:"starts_at"`
+
+	// EndsAt stores the optional finite entitlement expiry.
+	EndsAt *time.Time `json:"ends_at,omitempty"`
+
+	// UpdatedAt stores when the snapshot was last recomputed.
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// ActiveSanction stores one transport-ready active sanction returned in the
+// shared account aggregate.
+type ActiveSanction struct {
+	// SanctionCode stores the active sanction code.
+	SanctionCode string `json:"sanction_code"`
+
+	// Scope stores the machine-readable sanction scope.
+	Scope string `json:"scope"`
+
+	// ReasonCode stores the machine-readable sanction reason.
+	ReasonCode string `json:"reason_code"`
+
+	// Actor stores the audit actor metadata attached to the sanction.
+	Actor ActorRef `json:"actor"`
+
+	// AppliedAt stores when the sanction became active.
+	AppliedAt time.Time `json:"applied_at"`
+
+	// ExpiresAt stores the optional planned sanction expiry.
+	ExpiresAt *time.Time `json:"expires_at,omitempty"`
+}
+
+// ActiveLimit stores one transport-ready active user-specific limit override
+// returned in the shared account aggregate.
+type ActiveLimit struct {
+	// LimitCode stores the active limit code.
+	LimitCode string `json:"limit_code"`
+
+	// Value stores the current override value.
+	Value int `json:"value"`
+
+	// ReasonCode stores the machine-readable limit reason.
+	ReasonCode string `json:"reason_code"`
+
+	// Actor stores the audit actor metadata attached to the limit.
+	Actor ActorRef `json:"actor"`
+
+	// AppliedAt stores when the limit became active.
+	AppliedAt time.Time `json:"applied_at"`
+
+	// ExpiresAt stores the optional planned limit expiry.
+	ExpiresAt *time.Time `json:"expires_at,omitempty"`
+}
+
+// Account stores the transport-ready account aggregate shared by User Service
+// self-service read and mutation responses.
+type Account struct {
+	// UserID stores the durable regular-user identifier.
+	UserID string `json:"user_id"`
+
+	// Email stores the exact-after-trim login e-mail address.
+	Email string `json:"email"`
+
+	// RaceName stores the current user-facing race name.
+	RaceName string `json:"race_name"`
+
+	// PreferredLanguage stores the current BCP 47 language tag.
+	PreferredLanguage string `json:"preferred_language"`
+
+	// TimeZone stores the current IANA time-zone name.
+	TimeZone string `json:"time_zone"`
+
+	// DeclaredCountry stores the optional current effective declared country.
+	DeclaredCountry string `json:"declared_country,omitempty"`
+
+	// Entitlement stores the current entitlement snapshot.
+	Entitlement EntitlementSnapshot `json:"entitlement"`
+
+	// ActiveSanctions stores the current active sanctions sorted by code.
+	ActiveSanctions []ActiveSanction `json:"active_sanctions"`
+
+	// ActiveLimits stores the current active user-specific limits sorted by
+	// code.
+	ActiveLimits []ActiveLimit `json:"active_limits"`
+
+	// CreatedAt stores when the account was created.
+	CreatedAt time.Time `json:"created_at"`
+
+	// UpdatedAt stores when the account was last mutated.
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+// AccountResponse stores the success payload shared by the authenticated
+// GetMyAccount, UpdateMyProfile, and UpdateMySettings gateway message types.
+type AccountResponse struct {
+	// Account stores the current account aggregate.
+	Account Account `json:"account"`
+}
+
+// ErrorBody stores the machine-readable and human-readable failure payload
+// mirrored from the User Service trusted internal error envelope.
+type ErrorBody struct {
+	// Code stores the stable machine-readable failure code.
+	Code string `json:"code"`
+
+	// Message stores the client-safe failure message.
+	Message string `json:"message"`
+}
+
+// ErrorResponse stores the error payload returned by the authenticated
+// Gateway -> User boundary when User Service rejects a request semantically.
+type ErrorResponse struct {
+	// Error stores the mirrored error envelope body.
+	Error ErrorBody `json:"error"`
+}

pkg/schema/fbs/user.fbs

@@ -0,0 +1,78 @@
+// user contains FlatBuffers payloads used by the authenticated gateway
+// self-service boundary for User Service.
+namespace user;
+
+table GetMyAccountRequest {
+}
+
+table UpdateMyProfileRequest {
+  race_name:string;
+}
+
+table UpdateMySettingsRequest {
+  preferred_language:string;
+  time_zone:string;
+}
+
+table ActorRef {
+  type:string;
+  id:string;
+}
+
+table EntitlementSnapshot {
+  plan_code:string;
+  is_paid:bool;
+  source:string;
+  actor:ActorRef;
+  reason_code:string;
+  starts_at_ms:int64;
+  ends_at_ms:int64;
+  updated_at_ms:int64;
+}
+
+table ActiveSanction {
+  sanction_code:string;
+  scope:string;
+  reason_code:string;
+  actor:ActorRef;
+  applied_at_ms:int64;
+  expires_at_ms:int64;
+}
+
+table ActiveLimit {
+  limit_code:string;
+  value:int64;
+  reason_code:string;
+  actor:ActorRef;
+  applied_at_ms:int64;
+  expires_at_ms:int64;
+}
+
+table AccountView {
+  user_id:string;
+  email:string;
+  race_name:string;
+  preferred_language:string;
+  time_zone:string;
+  declared_country:string;
+  entitlement:EntitlementSnapshot;
+  active_sanctions:[ActiveSanction];
+  active_limits:[ActiveLimit];
+  created_at_ms:int64;
+  updated_at_ms:int64;
+}
+
+table AccountResponse {
+  account:AccountView;
+}
+
+table ErrorBody {
+  code:string;
+  message:string;
+}
+
+table ErrorResponse {
+  error:ErrorBody;
+}
+
+root_type AccountResponse;

pkg/schema/fbs/user/AccountResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type AccountResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsAccountResponse(buf []byte, offset flatbuffers.UOffsetT) *AccountResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &AccountResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishAccountResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsAccountResponse(buf []byte, offset flatbuffers.UOffsetT) *AccountResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &AccountResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedAccountResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *AccountResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *AccountResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *AccountResponse) Account(obj *AccountView) *AccountView {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(AccountView)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func AccountResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func AccountResponseAddAccount(builder *flatbuffers.Builder, account flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(account), 0)
+}
+func AccountResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/AccountView.go

@@ -0,0 +1,213 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type AccountView struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsAccountView(buf []byte, offset flatbuffers.UOffsetT) *AccountView {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &AccountView{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishAccountViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsAccountView(buf []byte, offset flatbuffers.UOffsetT) *AccountView {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &AccountView{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedAccountViewBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *AccountView) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *AccountView) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *AccountView) UserId() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) Email() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) RaceName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) PreferredLanguage() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) TimeZone() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) DeclaredCountry() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *AccountView) Entitlement(obj *EntitlementSnapshot) *EntitlementSnapshot {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(EntitlementSnapshot)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *AccountView) ActiveSanctions(obj *ActiveSanction, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *AccountView) ActiveSanctionsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *AccountView) ActiveLimits(obj *ActiveLimit, j int) bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		x := rcv._tab.Vector(o)
+		x += flatbuffers.UOffsetT(j) * 4
+		x = rcv._tab.Indirect(x)
+		obj.Init(rcv._tab.Bytes, x)
+		return true
+	}
+	return false
+}
+
+func (rcv *AccountView) ActiveLimitsLength() int {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+	if o != 0 {
+		return rcv._tab.VectorLen(o)
+	}
+	return 0
+}
+
+func (rcv *AccountView) CreatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *AccountView) MutateCreatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(22, n)
+}
+
+func (rcv *AccountView) UpdatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *AccountView) MutateUpdatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(24, n)
+}
+
+func AccountViewStart(builder *flatbuffers.Builder) {
+	builder.StartObject(11)
+}
+func AccountViewAddUserId(builder *flatbuffers.Builder, userId flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(userId), 0)
+}
+func AccountViewAddEmail(builder *flatbuffers.Builder, email flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(email), 0)
+}
+func AccountViewAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(raceName), 0)
+}
+func AccountViewAddPreferredLanguage(builder *flatbuffers.Builder, preferredLanguage flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(preferredLanguage), 0)
+}
+func AccountViewAddTimeZone(builder *flatbuffers.Builder, timeZone flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(timeZone), 0)
+}
+func AccountViewAddDeclaredCountry(builder *flatbuffers.Builder, declaredCountry flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(declaredCountry), 0)
+}
+func AccountViewAddEntitlement(builder *flatbuffers.Builder, entitlement flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(entitlement), 0)
+}
+func AccountViewAddActiveSanctions(builder *flatbuffers.Builder, activeSanctions flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(activeSanctions), 0)
+}
+func AccountViewStartActiveSanctionsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func AccountViewAddActiveLimits(builder *flatbuffers.Builder, activeLimits flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(activeLimits), 0)
+}
+func AccountViewStartActiveLimitsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+	return builder.StartVector(4, numElems, 4)
+}
+func AccountViewAddCreatedAtMs(builder *flatbuffers.Builder, createdAtMs int64) {
+	builder.PrependInt64Slot(9, createdAtMs, 0)
+}
+func AccountViewAddUpdatedAtMs(builder *flatbuffers.Builder, updatedAtMs int64) {
+	builder.PrependInt64Slot(10, updatedAtMs, 0)
+}
+func AccountViewEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/ActiveLimit.go

@@ -0,0 +1,132 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ActiveLimit struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsActiveLimit(buf []byte, offset flatbuffers.UOffsetT) *ActiveLimit {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ActiveLimit{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishActiveLimitBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsActiveLimit(buf []byte, offset flatbuffers.UOffsetT) *ActiveLimit {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ActiveLimit{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedActiveLimitBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ActiveLimit) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ActiveLimit) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ActiveLimit) LimitCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActiveLimit) Value() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ActiveLimit) MutateValue(n int64) bool {
+	return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func (rcv *ActiveLimit) ReasonCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActiveLimit) Actor(obj *ActorRef) *ActorRef {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ActorRef)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *ActiveLimit) AppliedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ActiveLimit) MutateAppliedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(12, n)
+}
+
+func (rcv *ActiveLimit) ExpiresAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ActiveLimit) MutateExpiresAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func ActiveLimitStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func ActiveLimitAddLimitCode(builder *flatbuffers.Builder, limitCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(limitCode), 0)
+}
+func ActiveLimitAddValue(builder *flatbuffers.Builder, value int64) {
+	builder.PrependInt64Slot(1, value, 0)
+}
+func ActiveLimitAddReasonCode(builder *flatbuffers.Builder, reasonCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(reasonCode), 0)
+}
+func ActiveLimitAddActor(builder *flatbuffers.Builder, actor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(actor), 0)
+}
+func ActiveLimitAddAppliedAtMs(builder *flatbuffers.Builder, appliedAtMs int64) {
+	builder.PrependInt64Slot(4, appliedAtMs, 0)
+}
+func ActiveLimitAddExpiresAtMs(builder *flatbuffers.Builder, expiresAtMs int64) {
+	builder.PrependInt64Slot(5, expiresAtMs, 0)
+}
+func ActiveLimitEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/ActiveSanction.go

@@ -0,0 +1,128 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ActiveSanction struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsActiveSanction(buf []byte, offset flatbuffers.UOffsetT) *ActiveSanction {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ActiveSanction{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishActiveSanctionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsActiveSanction(buf []byte, offset flatbuffers.UOffsetT) *ActiveSanction {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ActiveSanction{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedActiveSanctionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ActiveSanction) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ActiveSanction) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ActiveSanction) SanctionCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActiveSanction) Scope() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActiveSanction) ReasonCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActiveSanction) Actor(obj *ActorRef) *ActorRef {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ActorRef)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *ActiveSanction) AppliedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ActiveSanction) MutateAppliedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(12, n)
+}
+
+func (rcv *ActiveSanction) ExpiresAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *ActiveSanction) MutateExpiresAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func ActiveSanctionStart(builder *flatbuffers.Builder) {
+	builder.StartObject(6)
+}
+func ActiveSanctionAddSanctionCode(builder *flatbuffers.Builder, sanctionCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(sanctionCode), 0)
+}
+func ActiveSanctionAddScope(builder *flatbuffers.Builder, scope flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(scope), 0)
+}
+func ActiveSanctionAddReasonCode(builder *flatbuffers.Builder, reasonCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(reasonCode), 0)
+}
+func ActiveSanctionAddActor(builder *flatbuffers.Builder, actor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(actor), 0)
+}
+func ActiveSanctionAddAppliedAtMs(builder *flatbuffers.Builder, appliedAtMs int64) {
+	builder.PrependInt64Slot(4, appliedAtMs, 0)
+}
+func ActiveSanctionAddExpiresAtMs(builder *flatbuffers.Builder, expiresAtMs int64) {
+	builder.PrependInt64Slot(5, expiresAtMs, 0)
+}
+func ActiveSanctionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/ActorRef.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ActorRef struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsActorRef(buf []byte, offset flatbuffers.UOffsetT) *ActorRef {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ActorRef{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishActorRefBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsActorRef(buf []byte, offset flatbuffers.UOffsetT) *ActorRef {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ActorRef{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedActorRefBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ActorRef) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ActorRef) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ActorRef) Type() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ActorRef) Id() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ActorRefStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ActorRefAddType(builder *flatbuffers.Builder, type_ flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(type_), 0)
+}
+func ActorRefAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(id), 0)
+}
+func ActorRefEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/EntitlementSnapshot.go

@@ -0,0 +1,158 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type EntitlementSnapshot struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsEntitlementSnapshot(buf []byte, offset flatbuffers.UOffsetT) *EntitlementSnapshot {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &EntitlementSnapshot{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishEntitlementSnapshotBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsEntitlementSnapshot(buf []byte, offset flatbuffers.UOffsetT) *EntitlementSnapshot {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &EntitlementSnapshot{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedEntitlementSnapshotBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *EntitlementSnapshot) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *EntitlementSnapshot) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *EntitlementSnapshot) PlanCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *EntitlementSnapshot) IsPaid() bool {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetBool(o + rcv._tab.Pos)
+	}
+	return false
+}
+
+func (rcv *EntitlementSnapshot) MutateIsPaid(n bool) bool {
+	return rcv._tab.MutateBoolSlot(6, n)
+}
+
+func (rcv *EntitlementSnapshot) Source() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *EntitlementSnapshot) Actor(obj *ActorRef) *ActorRef {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ActorRef)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func (rcv *EntitlementSnapshot) ReasonCode() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *EntitlementSnapshot) StartsAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *EntitlementSnapshot) MutateStartsAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func (rcv *EntitlementSnapshot) EndsAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *EntitlementSnapshot) MutateEndsAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(16, n)
+}
+
+func (rcv *EntitlementSnapshot) UpdatedAtMs() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func (rcv *EntitlementSnapshot) MutateUpdatedAtMs(n int64) bool {
+	return rcv._tab.MutateInt64Slot(18, n)
+}
+
+func EntitlementSnapshotStart(builder *flatbuffers.Builder) {
+	builder.StartObject(8)
+}
+func EntitlementSnapshotAddPlanCode(builder *flatbuffers.Builder, planCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(planCode), 0)
+}
+func EntitlementSnapshotAddIsPaid(builder *flatbuffers.Builder, isPaid bool) {
+	builder.PrependBoolSlot(1, isPaid, false)
+}
+func EntitlementSnapshotAddSource(builder *flatbuffers.Builder, source flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(source), 0)
+}
+func EntitlementSnapshotAddActor(builder *flatbuffers.Builder, actor flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(actor), 0)
+}
+func EntitlementSnapshotAddReasonCode(builder *flatbuffers.Builder, reasonCode flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(reasonCode), 0)
+}
+func EntitlementSnapshotAddStartsAtMs(builder *flatbuffers.Builder, startsAtMs int64) {
+	builder.PrependInt64Slot(5, startsAtMs, 0)
+}
+func EntitlementSnapshotAddEndsAtMs(builder *flatbuffers.Builder, endsAtMs int64) {
+	builder.PrependInt64Slot(6, endsAtMs, 0)
+}
+func EntitlementSnapshotAddUpdatedAtMs(builder *flatbuffers.Builder, updatedAtMs int64) {
+	builder.PrependInt64Slot(7, updatedAtMs, 0)
+}
+func EntitlementSnapshotEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/ErrorBody.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ErrorBody struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorBody(buf []byte, offset flatbuffers.UOffsetT) *ErrorBody {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorBody{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorBodyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorBody) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorBody) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorBody) Code() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *ErrorBody) Message() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func ErrorBodyStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func ErrorBodyAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(code), 0)
+}
+func ErrorBodyAddMessage(builder *flatbuffers.Builder, message flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(message), 0)
+}
+func ErrorBodyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/ErrorResponse.go

@@ -0,0 +1,65 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type ErrorResponse struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsErrorResponse(buf []byte, offset flatbuffers.UOffsetT) *ErrorResponse {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &ErrorResponse{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedErrorResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *ErrorResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *ErrorResponse) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *ErrorResponse) Error(obj *ErrorBody) *ErrorBody {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(ErrorBody)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func ErrorResponseStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func ErrorResponseAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(error), 0)
+}
+func ErrorResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/GetMyAccountRequest.go

@@ -0,0 +1,49 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type GetMyAccountRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsGetMyAccountRequest(buf []byte, offset flatbuffers.UOffsetT) *GetMyAccountRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &GetMyAccountRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishGetMyAccountRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsGetMyAccountRequest(buf []byte, offset flatbuffers.UOffsetT) *GetMyAccountRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &GetMyAccountRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedGetMyAccountRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *GetMyAccountRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *GetMyAccountRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func GetMyAccountRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func GetMyAccountRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/UpdateMyProfileRequest.go

@@ -0,0 +1,60 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UpdateMyProfileRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUpdateMyProfileRequest(buf []byte, offset flatbuffers.UOffsetT) *UpdateMyProfileRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &UpdateMyProfileRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUpdateMyProfileRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUpdateMyProfileRequest(buf []byte, offset flatbuffers.UOffsetT) *UpdateMyProfileRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &UpdateMyProfileRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUpdateMyProfileRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *UpdateMyProfileRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UpdateMyProfileRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *UpdateMyProfileRequest) RaceName() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func UpdateMyProfileRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(1)
+}
+func UpdateMyProfileRequestAddRaceName(builder *flatbuffers.Builder, raceName flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(raceName), 0)
+}
+func UpdateMyProfileRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/schema/fbs/user/UpdateMySettingsRequest.go

@@ -0,0 +1,71 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package user
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type UpdateMySettingsRequest struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsUpdateMySettingsRequest(buf []byte, offset flatbuffers.UOffsetT) *UpdateMySettingsRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &UpdateMySettingsRequest{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func FinishUpdateMySettingsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.Finish(offset)
+}
+
+func GetSizePrefixedRootAsUpdateMySettingsRequest(buf []byte, offset flatbuffers.UOffsetT) *UpdateMySettingsRequest {
+	n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+	x := &UpdateMySettingsRequest{}
+	x.Init(buf, n+offset+flatbuffers.SizeUint32)
+	return x
+}
+
+func FinishSizePrefixedUpdateMySettingsRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
+	builder.FinishSizePrefixed(offset)
+}
+
+func (rcv *UpdateMySettingsRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *UpdateMySettingsRequest) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func (rcv *UpdateMySettingsRequest) PreferredLanguage() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func (rcv *UpdateMySettingsRequest) TimeZone() []byte {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.ByteVector(o + rcv._tab.Pos)
+	}
+	return nil
+}
+
+func UpdateMySettingsRequestStart(builder *flatbuffers.Builder) {
+	builder.StartObject(2)
+}
+func UpdateMySettingsRequestAddPreferredLanguage(builder *flatbuffers.Builder, preferredLanguage flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(preferredLanguage), 0)
+}
+func UpdateMySettingsRequestAddTimeZone(builder *flatbuffers.Builder, timeZone flatbuffers.UOffsetT) {
+	builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(timeZone), 0)
+}
+func UpdateMySettingsRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}

pkg/transcoder/user.go

@@ -0,0 +1,504 @@
+package transcoder
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	usermodel "galaxy/model/user"
+	userfbs "galaxy/schema/fbs/user"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+// GetMyAccountRequestToPayload converts usermodel.GetMyAccountRequest to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func GetMyAccountRequestToPayload(request *usermodel.GetMyAccountRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode get my account request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(32)
+	userfbs.GetMyAccountRequestStart(builder)
+	offset := userfbs.GetMyAccountRequestEnd(builder)
+	userfbs.FinishGetMyAccountRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToGetMyAccountRequest converts FlatBuffers payload bytes into
+// usermodel.GetMyAccountRequest.
+func PayloadToGetMyAccountRequest(data []byte) (result *usermodel.GetMyAccountRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode get my account request payload: data is empty")
+	}
+
+	defer recoverUserDecodePanic("decode get my account request payload", &result, &err)
+
+	_ = userfbs.GetRootAsGetMyAccountRequest(data, 0)
+	return &usermodel.GetMyAccountRequest{}, nil
+}
+
+// UpdateMyProfileRequestToPayload converts usermodel.UpdateMyProfileRequest to
+// FlatBuffers bytes suitable for the authenticated gateway transport.
+func UpdateMyProfileRequestToPayload(request *usermodel.UpdateMyProfileRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode update my profile request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(128)
+	raceName := builder.CreateString(request.RaceName)
+
+	userfbs.UpdateMyProfileRequestStart(builder)
+	userfbs.UpdateMyProfileRequestAddRaceName(builder, raceName)
+	offset := userfbs.UpdateMyProfileRequestEnd(builder)
+	userfbs.FinishUpdateMyProfileRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToUpdateMyProfileRequest converts FlatBuffers payload bytes into
+// usermodel.UpdateMyProfileRequest.
+func PayloadToUpdateMyProfileRequest(data []byte) (result *usermodel.UpdateMyProfileRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode update my profile request payload: data is empty")
+	}
+
+	defer recoverUserDecodePanic("decode update my profile request payload", &result, &err)
+
+	request := userfbs.GetRootAsUpdateMyProfileRequest(data, 0)
+	return &usermodel.UpdateMyProfileRequest{
+		RaceName: string(request.RaceName()),
+	}, nil
+}
+
+// UpdateMySettingsRequestToPayload converts
+// usermodel.UpdateMySettingsRequest to FlatBuffers bytes suitable for the
+// authenticated gateway transport.
+func UpdateMySettingsRequestToPayload(request *usermodel.UpdateMySettingsRequest) ([]byte, error) {
+	if request == nil {
+		return nil, errors.New("encode update my settings request payload: request is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(128)
+	preferredLanguage := builder.CreateString(request.PreferredLanguage)
+	timeZone := builder.CreateString(request.TimeZone)
+
+	userfbs.UpdateMySettingsRequestStart(builder)
+	userfbs.UpdateMySettingsRequestAddPreferredLanguage(builder, preferredLanguage)
+	userfbs.UpdateMySettingsRequestAddTimeZone(builder, timeZone)
+	offset := userfbs.UpdateMySettingsRequestEnd(builder)
+	userfbs.FinishUpdateMySettingsRequestBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToUpdateMySettingsRequest converts FlatBuffers payload bytes into
+// usermodel.UpdateMySettingsRequest.
+func PayloadToUpdateMySettingsRequest(data []byte) (result *usermodel.UpdateMySettingsRequest, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode update my settings request payload: data is empty")
+	}
+
+	defer recoverUserDecodePanic("decode update my settings request payload", &result, &err)
+
+	request := userfbs.GetRootAsUpdateMySettingsRequest(data, 0)
+	return &usermodel.UpdateMySettingsRequest{
+		PreferredLanguage: string(request.PreferredLanguage()),
+		TimeZone:          string(request.TimeZone()),
+	}, nil
+}
+
+// AccountResponseToPayload converts usermodel.AccountResponse to FlatBuffers
+// bytes suitable for the authenticated gateway transport.
+func AccountResponseToPayload(response *usermodel.AccountResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode account response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(512)
+	accountOffset, err := encodeAccount(builder, response.Account)
+	if err != nil {
+		return nil, fmt.Errorf("encode account response payload: %w", err)
+	}
+
+	userfbs.AccountResponseStart(builder)
+	userfbs.AccountResponseAddAccount(builder, accountOffset)
+	offset := userfbs.AccountResponseEnd(builder)
+	userfbs.FinishAccountResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToAccountResponse converts FlatBuffers payload bytes into
+// usermodel.AccountResponse.
+func PayloadToAccountResponse(data []byte) (result *usermodel.AccountResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode account response payload: data is empty")
+	}
+
+	defer recoverUserDecodePanic("decode account response payload", &result, &err)
+
+	response := userfbs.GetRootAsAccountResponse(data, 0)
+	account := response.Account(nil)
+	if account == nil {
+		return nil, errors.New("decode account response payload: account is missing")
+	}
+
+	decodedAccount, err := decodeAccount(account)
+	if err != nil {
+		return nil, fmt.Errorf("decode account response payload: %w", err)
+	}
+
+	return &usermodel.AccountResponse{Account: decodedAccount}, nil
+}
+
+// ErrorResponseToPayload converts usermodel.ErrorResponse to FlatBuffers bytes
+// suitable for the authenticated gateway transport.
+func ErrorResponseToPayload(response *usermodel.ErrorResponse) ([]byte, error) {
+	if response == nil {
+		return nil, errors.New("encode error response payload: response is nil")
+	}
+
+	builder := flatbuffers.NewBuilder(128)
+	errorOffset := encodeErrorBody(builder, response.Error)
+
+	userfbs.ErrorResponseStart(builder)
+	userfbs.ErrorResponseAddError(builder, errorOffset)
+	offset := userfbs.ErrorResponseEnd(builder)
+	userfbs.FinishErrorResponseBuffer(builder, offset)
+
+	return builder.FinishedBytes(), nil
+}
+
+// PayloadToErrorResponse converts FlatBuffers payload bytes into
+// usermodel.ErrorResponse.
+func PayloadToErrorResponse(data []byte) (result *usermodel.ErrorResponse, err error) {
+	if len(data) == 0 {
+		return nil, errors.New("decode error response payload: data is empty")
+	}
+
+	defer recoverUserDecodePanic("decode error response payload", &result, &err)
+
+	response := userfbs.GetRootAsErrorResponse(data, 0)
+	errorBody := response.Error(nil)
+	if errorBody == nil {
+		return nil, errors.New("decode error response payload: error is missing")
+	}
+
+	return &usermodel.ErrorResponse{
+		Error: usermodel.ErrorBody{
+			Code:    string(errorBody.Code()),
+			Message: string(errorBody.Message()),
+		},
+	}, nil
+}
+
+func encodeAccount(builder *flatbuffers.Builder, account usermodel.Account) (flatbuffers.UOffsetT, error) {
+	entitlementOffset, err := encodeEntitlementSnapshot(builder, account.Entitlement)
+	if err != nil {
+		return 0, fmt.Errorf("encode account: %w", err)
+	}
+
+	activeSanctionOffsets := make([]flatbuffers.UOffsetT, len(account.ActiveSanctions))
+	for index := range account.ActiveSanctions {
+		activeSanctionOffsets[index], err = encodeActiveSanction(builder, account.ActiveSanctions[index])
+		if err != nil {
+			return 0, fmt.Errorf("encode account active sanction %d: %w", index, err)
+		}
+	}
+
+	var activeSanctionsVector flatbuffers.UOffsetT
+	if len(activeSanctionOffsets) > 0 {
+		userfbs.AccountViewStartActiveSanctionsVector(builder, len(activeSanctionOffsets))
+		for index := len(activeSanctionOffsets) - 1; index >= 0; index-- {
+			builder.PrependUOffsetT(activeSanctionOffsets[index])
+		}
+		activeSanctionsVector = builder.EndVector(len(activeSanctionOffsets))
+	}
+
+	activeLimitOffsets := make([]flatbuffers.UOffsetT, len(account.ActiveLimits))
+	for index := range account.ActiveLimits {
+		activeLimitOffsets[index], err = encodeActiveLimit(builder, account.ActiveLimits[index])
+		if err != nil {
+			return 0, fmt.Errorf("encode account active limit %d: %w", index, err)
+		}
+	}
+
+	var activeLimitsVector flatbuffers.UOffsetT
+	if len(activeLimitOffsets) > 0 {
+		userfbs.AccountViewStartActiveLimitsVector(builder, len(activeLimitOffsets))
+		for index := len(activeLimitOffsets) - 1; index >= 0; index-- {
+			builder.PrependUOffsetT(activeLimitOffsets[index])
+		}
+		activeLimitsVector = builder.EndVector(len(activeLimitOffsets))
+	}
+
+	userID := builder.CreateString(account.UserID)
+	email := builder.CreateString(account.Email)
+	raceName := builder.CreateString(account.RaceName)
+	preferredLanguage := builder.CreateString(account.PreferredLanguage)
+	timeZone := builder.CreateString(account.TimeZone)
+
+	var declaredCountry flatbuffers.UOffsetT
+	if account.DeclaredCountry != "" {
+		declaredCountry = builder.CreateString(account.DeclaredCountry)
+	}
+
+	userfbs.AccountViewStart(builder)
+	userfbs.AccountViewAddUserId(builder, userID)
+	userfbs.AccountViewAddEmail(builder, email)
+	userfbs.AccountViewAddRaceName(builder, raceName)
+	userfbs.AccountViewAddPreferredLanguage(builder, preferredLanguage)
+	userfbs.AccountViewAddTimeZone(builder, timeZone)
+	if declaredCountry != 0 {
+		userfbs.AccountViewAddDeclaredCountry(builder, declaredCountry)
+	}
+	userfbs.AccountViewAddEntitlement(builder, entitlementOffset)
+	if activeSanctionsVector != 0 {
+		userfbs.AccountViewAddActiveSanctions(builder, activeSanctionsVector)
+	}
+	if activeLimitsVector != 0 {
+		userfbs.AccountViewAddActiveLimits(builder, activeLimitsVector)
+	}
+	userfbs.AccountViewAddCreatedAtMs(builder, account.CreatedAt.UTC().UnixMilli())
+	userfbs.AccountViewAddUpdatedAtMs(builder, account.UpdatedAt.UTC().UnixMilli())
+
+	return userfbs.AccountViewEnd(builder), nil
+}
+
+func decodeAccount(account *userfbs.AccountView) (usermodel.Account, error) {
+	entitlement := account.Entitlement(nil)
+	if entitlement == nil {
+		return usermodel.Account{}, errors.New("account entitlement is missing")
+	}
+
+	decodedEntitlement, err := decodeEntitlementSnapshot(entitlement)
+	if err != nil {
+		return usermodel.Account{}, fmt.Errorf("decode account entitlement: %w", err)
+	}
+
+	createdAt := time.UnixMilli(account.CreatedAtMs()).UTC()
+	updatedAt := time.UnixMilli(account.UpdatedAtMs()).UTC()
+
+	result := usermodel.Account{
+		UserID:            string(account.UserId()),
+		Email:             string(account.Email()),
+		RaceName:          string(account.RaceName()),
+		PreferredLanguage: string(account.PreferredLanguage()),
+		TimeZone:          string(account.TimeZone()),
+		DeclaredCountry:   string(account.DeclaredCountry()),
+		Entitlement:       decodedEntitlement,
+		ActiveSanctions:   make([]usermodel.ActiveSanction, 0, account.ActiveSanctionsLength()),
+		ActiveLimits:      make([]usermodel.ActiveLimit, 0, account.ActiveLimitsLength()),
+		CreatedAt:         createdAt,
+		UpdatedAt:         updatedAt,
+	}
+
+	activeSanction := new(userfbs.ActiveSanction)
+	for index := 0; index < account.ActiveSanctionsLength(); index++ {
+		if !account.ActiveSanctions(activeSanction, index) {
+			return usermodel.Account{}, fmt.Errorf("account active sanction %d is missing", index)
+		}
+
+		decodedSanction, err := decodeActiveSanction(activeSanction)
+		if err != nil {
+			return usermodel.Account{}, fmt.Errorf("decode account active sanction %d: %w", index, err)
+		}
+		result.ActiveSanctions = append(result.ActiveSanctions, decodedSanction)
+	}
+
+	activeLimit := new(userfbs.ActiveLimit)
+	for index := 0; index < account.ActiveLimitsLength(); index++ {
+		if !account.ActiveLimits(activeLimit, index) {
+			return usermodel.Account{}, fmt.Errorf("account active limit %d is missing", index)
+		}
+
+		decodedLimit, err := decodeActiveLimit(activeLimit)
+		if err != nil {
+			return usermodel.Account{}, fmt.Errorf("decode account active limit %d: %w", index, err)
+		}
+		result.ActiveLimits = append(result.ActiveLimits, decodedLimit)
+	}
+
+	return result, nil
+}
+
+func encodeEntitlementSnapshot(builder *flatbuffers.Builder, snapshot usermodel.EntitlementSnapshot) (flatbuffers.UOffsetT, error) {
+	actorOffset := encodeActorRef(builder, snapshot.Actor)
+	planCode := builder.CreateString(snapshot.PlanCode)
+	source := builder.CreateString(snapshot.Source)
+	reasonCode := builder.CreateString(snapshot.ReasonCode)
+
+	userfbs.EntitlementSnapshotStart(builder)
+	userfbs.EntitlementSnapshotAddPlanCode(builder, planCode)
+	userfbs.EntitlementSnapshotAddIsPaid(builder, snapshot.IsPaid)
+	userfbs.EntitlementSnapshotAddSource(builder, source)
+	userfbs.EntitlementSnapshotAddActor(builder, actorOffset)
+	userfbs.EntitlementSnapshotAddReasonCode(builder, reasonCode)
+	userfbs.EntitlementSnapshotAddStartsAtMs(builder, snapshot.StartsAt.UTC().UnixMilli())
+	if snapshot.EndsAt != nil {
+		userfbs.EntitlementSnapshotAddEndsAtMs(builder, snapshot.EndsAt.UTC().UnixMilli())
+	}
+	userfbs.EntitlementSnapshotAddUpdatedAtMs(builder, snapshot.UpdatedAt.UTC().UnixMilli())
+
+	return userfbs.EntitlementSnapshotEnd(builder), nil
+}
+
+func decodeEntitlementSnapshot(snapshot *userfbs.EntitlementSnapshot) (usermodel.EntitlementSnapshot, error) {
+	actor := snapshot.Actor(nil)
+	if actor == nil {
+		return usermodel.EntitlementSnapshot{}, errors.New("entitlement actor is missing")
+	}
+
+	decodedActor, err := decodeActorRef(actor)
+	if err != nil {
+		return usermodel.EntitlementSnapshot{}, fmt.Errorf("decode entitlement actor: %w", err)
+	}
+
+	return usermodel.EntitlementSnapshot{
+		PlanCode:   string(snapshot.PlanCode()),
+		IsPaid:     snapshot.IsPaid(),
+		Source:     string(snapshot.Source()),
+		Actor:      decodedActor,
+		ReasonCode: string(snapshot.ReasonCode()),
+		StartsAt:   time.UnixMilli(snapshot.StartsAtMs()).UTC(),
+		EndsAt:     optionalUnixMilli(snapshot.EndsAtMs()),
+		UpdatedAt:  time.UnixMilli(snapshot.UpdatedAtMs()).UTC(),
+	}, nil
+}
+
+func encodeActiveSanction(builder *flatbuffers.Builder, sanction usermodel.ActiveSanction) (flatbuffers.UOffsetT, error) {
+	actorOffset := encodeActorRef(builder, sanction.Actor)
+	sanctionCode := builder.CreateString(sanction.SanctionCode)
+	scope := builder.CreateString(sanction.Scope)
+	reasonCode := builder.CreateString(sanction.ReasonCode)
+
+	userfbs.ActiveSanctionStart(builder)
+	userfbs.ActiveSanctionAddSanctionCode(builder, sanctionCode)
+	userfbs.ActiveSanctionAddScope(builder, scope)
+	userfbs.ActiveSanctionAddReasonCode(builder, reasonCode)
+	userfbs.ActiveSanctionAddActor(builder, actorOffset)
+	userfbs.ActiveSanctionAddAppliedAtMs(builder, sanction.AppliedAt.UTC().UnixMilli())
+	if sanction.ExpiresAt != nil {
+		userfbs.ActiveSanctionAddExpiresAtMs(builder, sanction.ExpiresAt.UTC().UnixMilli())
+	}
+
+	return userfbs.ActiveSanctionEnd(builder), nil
+}
+
+func decodeActiveSanction(sanction *userfbs.ActiveSanction) (usermodel.ActiveSanction, error) {
+	actor := sanction.Actor(nil)
+	if actor == nil {
+		return usermodel.ActiveSanction{}, errors.New("sanction actor is missing")
+	}
+
+	decodedActor, err := decodeActorRef(actor)
+	if err != nil {
+		return usermodel.ActiveSanction{}, fmt.Errorf("decode sanction actor: %w", err)
+	}
+
+	return usermodel.ActiveSanction{
+		SanctionCode: string(sanction.SanctionCode()),
+		Scope:        string(sanction.Scope()),
+		ReasonCode:   string(sanction.ReasonCode()),
+		Actor:        decodedActor,
+		AppliedAt:    time.UnixMilli(sanction.AppliedAtMs()).UTC(),
+		ExpiresAt:    optionalUnixMilli(sanction.ExpiresAtMs()),
+	}, nil
+}
+
+func encodeActiveLimit(builder *flatbuffers.Builder, limit usermodel.ActiveLimit) (flatbuffers.UOffsetT, error) {
+	actorOffset := encodeActorRef(builder, limit.Actor)
+	limitCode := builder.CreateString(limit.LimitCode)
+	reasonCode := builder.CreateString(limit.ReasonCode)
+
+	userfbs.ActiveLimitStart(builder)
+	userfbs.ActiveLimitAddLimitCode(builder, limitCode)
+	userfbs.ActiveLimitAddValue(builder, int64(limit.Value))
+	userfbs.ActiveLimitAddReasonCode(builder, reasonCode)
+	userfbs.ActiveLimitAddActor(builder, actorOffset)
+	userfbs.ActiveLimitAddAppliedAtMs(builder, limit.AppliedAt.UTC().UnixMilli())
+	if limit.ExpiresAt != nil {
+		userfbs.ActiveLimitAddExpiresAtMs(builder, limit.ExpiresAt.UTC().UnixMilli())
+	}
+
+	return userfbs.ActiveLimitEnd(builder), nil
+}
+
+func decodeActiveLimit(limit *userfbs.ActiveLimit) (usermodel.ActiveLimit, error) {
+	actor := limit.Actor(nil)
+	if actor == nil {
+		return usermodel.ActiveLimit{}, errors.New("limit actor is missing")
+	}
+
+	decodedActor, err := decodeActorRef(actor)
+	if err != nil {
+		return usermodel.ActiveLimit{}, fmt.Errorf("decode limit actor: %w", err)
+	}
+
+	value, err := int64ToInt(limit.Value(), "value")
+	if err != nil {
+		return usermodel.ActiveLimit{}, err
+	}
+
+	return usermodel.ActiveLimit{
+		LimitCode:  string(limit.LimitCode()),
+		Value:      value,
+		ReasonCode: string(limit.ReasonCode()),
+		Actor:      decodedActor,
+		AppliedAt:  time.UnixMilli(limit.AppliedAtMs()).UTC(),
+		ExpiresAt:  optionalUnixMilli(limit.ExpiresAtMs()),
+	}, nil
+}
+
+func encodeActorRef(builder *flatbuffers.Builder, actor usermodel.ActorRef) flatbuffers.UOffsetT {
+	actorType := builder.CreateString(actor.Type)
+
+	var actorID flatbuffers.UOffsetT
+	if actor.ID != "" {
+		actorID = builder.CreateString(actor.ID)
+	}
+
+	userfbs.ActorRefStart(builder)
+	userfbs.ActorRefAddType(builder, actorType)
+	if actorID != 0 {
+		userfbs.ActorRefAddId(builder, actorID)
+	}
+
+	return userfbs.ActorRefEnd(builder)
+}
+
+func decodeActorRef(actor *userfbs.ActorRef) (usermodel.ActorRef, error) {
+	return usermodel.ActorRef{
+		Type: string(actor.Type()),
+		ID:   string(actor.Id()),
+	}, nil
+}
+
+func encodeErrorBody(builder *flatbuffers.Builder, errorBody usermodel.ErrorBody) flatbuffers.UOffsetT {
+	code := builder.CreateString(errorBody.Code)
+	message := builder.CreateString(errorBody.Message)
+
+	userfbs.ErrorBodyStart(builder)
+	userfbs.ErrorBodyAddCode(builder, code)
+	userfbs.ErrorBodyAddMessage(builder, message)
+
+	return userfbs.ErrorBodyEnd(builder)
+}
+
+func optionalUnixMilli(value int64) *time.Time {
+	if value == 0 {
+		return nil
+	}
+
+	decoded := time.UnixMilli(value).UTC()
+	return &decoded
+}
+
+func recoverUserDecodePanic[T any](message string, result **T, err *error) {
+	if recovered := recover(); recovered != nil {
+		*result = nil
+		*err = fmt.Errorf("%s: panic recovered: %v", message, recovered)
+	}
+}

pkg/transcoder/user_test.go

@@ -0,0 +1,468 @@
+package transcoder
+
+import (
+	"reflect"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	usermodel "galaxy/model/user"
+	userfbs "galaxy/schema/fbs/user"
+
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+func TestUserRequestPayloadRoundTrips(t *testing.T) {
+	t.Parallel()
+
+	getPayload, err := GetMyAccountRequestToPayload(&usermodel.GetMyAccountRequest{})
+	if err != nil {
+		t.Fatalf("encode get my account request: %v", err)
+	}
+
+	getDecoded, err := PayloadToGetMyAccountRequest(getPayload)
+	if err != nil {
+		t.Fatalf("decode get my account request: %v", err)
+	}
+	if !reflect.DeepEqual(&usermodel.GetMyAccountRequest{}, getDecoded) {
+		t.Fatalf("get my account request mismatch: %#v", getDecoded)
+	}
+
+	profileSource := &usermodel.UpdateMyProfileRequest{RaceName: "Nova Prime"}
+	profilePayload, err := UpdateMyProfileRequestToPayload(profileSource)
+	if err != nil {
+		t.Fatalf("encode update my profile request: %v", err)
+	}
+
+	profileDecoded, err := PayloadToUpdateMyProfileRequest(profilePayload)
+	if err != nil {
+		t.Fatalf("decode update my profile request: %v", err)
+	}
+	if !reflect.DeepEqual(profileSource, profileDecoded) {
+		t.Fatalf("update my profile request mismatch\nsource: %#v\ndecoded:%#v", profileSource, profileDecoded)
+	}
+
+	settingsSource := &usermodel.UpdateMySettingsRequest{
+		PreferredLanguage: "en-US",
+		TimeZone:          "Europe/Kaliningrad",
+	}
+	settingsPayload, err := UpdateMySettingsRequestToPayload(settingsSource)
+	if err != nil {
+		t.Fatalf("encode update my settings request: %v", err)
+	}
+
+	settingsDecoded, err := PayloadToUpdateMySettingsRequest(settingsPayload)
+	if err != nil {
+		t.Fatalf("decode update my settings request: %v", err)
+	}
+	if !reflect.DeepEqual(settingsSource, settingsDecoded) {
+		t.Fatalf("update my settings request mismatch\nsource: %#v\ndecoded:%#v", settingsSource, settingsDecoded)
+	}
+}
+
+func TestAccountResponsePayloadRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	now := time.Date(2026, time.April, 9, 10, 0, 0, 0, time.UTC)
+	expiresAt := now.Add(30 * 24 * time.Hour)
+	limitExpiresAt := now.Add(90 * 24 * time.Hour)
+
+	source := &usermodel.AccountResponse{
+		Account: usermodel.Account{
+			UserID:            "user-123",
+			Email:             "pilot@example.com",
+			RaceName:          "Pilot Nova",
+			PreferredLanguage: "en",
+			TimeZone:          "Europe/Kaliningrad",
+			DeclaredCountry:   "DE",
+			Entitlement: usermodel.EntitlementSnapshot{
+				PlanCode:   "paid_monthly",
+				IsPaid:     true,
+				Source:     "billing",
+				Actor:      usermodel.ActorRef{Type: "billing", ID: "invoice-1"},
+				ReasonCode: "renewal",
+				StartsAt:   now,
+				EndsAt:     &expiresAt,
+				UpdatedAt:  now,
+			},
+			ActiveSanctions: []usermodel.ActiveSanction{
+				{
+					SanctionCode: "profile_update_block",
+					Scope:        "lobby",
+					ReasonCode:   "manual_block",
+					Actor:        usermodel.ActorRef{Type: "admin", ID: "admin-1"},
+					AppliedAt:    now,
+					ExpiresAt:    &expiresAt,
+				},
+			},
+			ActiveLimits: []usermodel.ActiveLimit{
+				{
+					LimitCode:  "max_owned_private_games",
+					Value:      3,
+					ReasonCode: "manual_override",
+					Actor:      usermodel.ActorRef{Type: "admin", ID: "admin-1"},
+					AppliedAt:  now,
+					ExpiresAt:  &limitExpiresAt,
+				},
+			},
+			CreatedAt: now,
+			UpdatedAt: now.Add(time.Hour),
+		},
+	}
+
+	payload, err := AccountResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode account response: %v", err)
+	}
+
+	decoded, err := PayloadToAccountResponse(payload)
+	if err != nil {
+		t.Fatalf("decode account response: %v", err)
+	}
+
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("account response mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestErrorResponsePayloadRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	source := &usermodel.ErrorResponse{
+		Error: usermodel.ErrorBody{
+			Code:    "conflict",
+			Message: "request conflicts with current state",
+		},
+	}
+
+	payload, err := ErrorResponseToPayload(source)
+	if err != nil {
+		t.Fatalf("encode error response: %v", err)
+	}
+
+	decoded, err := PayloadToErrorResponse(payload)
+	if err != nil {
+		t.Fatalf("decode error response: %v", err)
+	}
+
+	if !reflect.DeepEqual(source, decoded) {
+		t.Fatalf("error response mismatch\nsource: %#v\ndecoded:%#v", source, decoded)
+	}
+}
+
+func TestUserPayloadEncodersRejectNilInputs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "get my account request",
+			call: func() error {
+				_, err := GetMyAccountRequestToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "update my profile request",
+			call: func() error {
+				_, err := UpdateMyProfileRequestToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "update my settings request",
+			call: func() error {
+				_, err := UpdateMySettingsRequestToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "account response",
+			call: func() error {
+				_, err := AccountResponseToPayload(nil)
+				return err
+			},
+		},
+		{
+			name: "error response",
+			call: func() error {
+				_, err := ErrorResponseToPayload(nil)
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if err := tt.call(); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestUserPayloadDecodersRejectEmptyPayloads(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "get my account request",
+			call: func() error {
+				_, err := PayloadToGetMyAccountRequest(nil)
+				return err
+			},
+		},
+		{
+			name: "update my profile request",
+			call: func() error {
+				_, err := PayloadToUpdateMyProfileRequest(nil)
+				return err
+			},
+		},
+		{
+			name: "update my settings request",
+			call: func() error {
+				_, err := PayloadToUpdateMySettingsRequest(nil)
+				return err
+			},
+		},
+		{
+			name: "account response",
+			call: func() error {
+				_, err := PayloadToAccountResponse(nil)
+				return err
+			},
+		},
+		{
+			name: "error response",
+			call: func() error {
+				_, err := PayloadToErrorResponse(nil)
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if err := tt.call(); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestUserPayloadDecodersRecoverFromGarbagePayloads(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		call func() error
+	}{
+		{
+			name: "get my account request",
+			call: func() error {
+				_, err := PayloadToGetMyAccountRequest([]byte{0x01, 0x02, 0x03})
+				return err
+			},
+		},
+		{
+			name: "update my profile request",
+			call: func() error {
+				_, err := PayloadToUpdateMyProfileRequest([]byte{0x01, 0x02, 0x03})
+				return err
+			},
+		},
+		{
+			name: "update my settings request",
+			call: func() error {
+				_, err := PayloadToUpdateMySettingsRequest([]byte{0x01, 0x02, 0x03})
+				return err
+			},
+		},
+		{
+			name: "account response",
+			call: func() error {
+				_, err := PayloadToAccountResponse([]byte{0x01, 0x02, 0x03})
+				return err
+			},
+		},
+		{
+			name: "error response",
+			call: func() error {
+				_, err := PayloadToErrorResponse([]byte{0x01, 0x02, 0x03})
+				return err
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			if err := tt.call(); err == nil {
+				t.Fatal("expected error")
+			}
+		})
+	}
+}
+
+func TestPayloadToAccountResponseRejectsMissingAccount(t *testing.T) {
+	t.Parallel()
+
+	builder := flatbuffers.NewBuilder(64)
+	userfbs.AccountResponseStart(builder)
+	offset := userfbs.AccountResponseEnd(builder)
+	userfbs.FinishAccountResponseBuffer(builder, offset)
+
+	_, err := PayloadToAccountResponse(builder.FinishedBytes())
+	if err == nil {
+		t.Fatal("expected error for missing account")
+	}
+	if !strings.Contains(err.Error(), "account is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToAccountResponseRejectsMissingEntitlement(t *testing.T) {
+	t.Parallel()
+
+	payload := buildAccountResponsePayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		userID := builder.CreateString("user-123")
+		email := builder.CreateString("pilot@example.com")
+		raceName := builder.CreateString("Pilot Nova")
+		preferredLanguage := builder.CreateString("en")
+		timeZone := builder.CreateString("Europe/Kaliningrad")
+
+		userfbs.AccountViewStart(builder)
+		userfbs.AccountViewAddUserId(builder, userID)
+		userfbs.AccountViewAddEmail(builder, email)
+		userfbs.AccountViewAddRaceName(builder, raceName)
+		userfbs.AccountViewAddPreferredLanguage(builder, preferredLanguage)
+		userfbs.AccountViewAddTimeZone(builder, timeZone)
+		userfbs.AccountViewAddCreatedAtMs(builder, 1)
+		userfbs.AccountViewAddUpdatedAtMs(builder, 2)
+		return userfbs.AccountViewEnd(builder)
+	})
+
+	_, err := PayloadToAccountResponse(payload)
+	if err == nil {
+		t.Fatal("expected error for missing entitlement")
+	}
+	if !strings.Contains(err.Error(), "entitlement is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToAccountResponseRejectsOverflowLimitValue(t *testing.T) {
+	t.Parallel()
+
+	if strconv.IntSize == 64 {
+		t.Skip("int overflow from int64 is not possible on 64-bit runtime")
+	}
+
+	maxInt := int64(int(^uint(0) >> 1))
+	overflow := maxInt + 1
+	nowMS := int64(1)
+
+	payload := buildAccountResponsePayload(func(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+		actorType := builder.CreateString("admin")
+		userfbs.ActorRefStart(builder)
+		userfbs.ActorRefAddType(builder, actorType)
+		actorOffset := userfbs.ActorRefEnd(builder)
+
+		planCode := builder.CreateString("free")
+		source := builder.CreateString("auth_registration")
+		reasonCode := builder.CreateString("initial_free_entitlement")
+		userfbs.EntitlementSnapshotStart(builder)
+		userfbs.EntitlementSnapshotAddPlanCode(builder, planCode)
+		userfbs.EntitlementSnapshotAddSource(builder, source)
+		userfbs.EntitlementSnapshotAddActor(builder, actorOffset)
+		userfbs.EntitlementSnapshotAddReasonCode(builder, reasonCode)
+		userfbs.EntitlementSnapshotAddStartsAtMs(builder, nowMS)
+		userfbs.EntitlementSnapshotAddUpdatedAtMs(builder, nowMS)
+		entitlementOffset := userfbs.EntitlementSnapshotEnd(builder)
+
+		limitCode := builder.CreateString("max_owned_private_games")
+		limitReasonCode := builder.CreateString("manual_override")
+		userfbs.ActiveLimitStart(builder)
+		userfbs.ActiveLimitAddLimitCode(builder, limitCode)
+		userfbs.ActiveLimitAddValue(builder, overflow)
+		userfbs.ActiveLimitAddReasonCode(builder, limitReasonCode)
+		userfbs.ActiveLimitAddActor(builder, actorOffset)
+		userfbs.ActiveLimitAddAppliedAtMs(builder, nowMS)
+		limitOffset := userfbs.ActiveLimitEnd(builder)
+
+		userfbs.AccountViewStartActiveLimitsVector(builder, 1)
+		builder.PrependUOffsetT(limitOffset)
+		limitsVector := builder.EndVector(1)
+
+		userID := builder.CreateString("user-123")
+		email := builder.CreateString("pilot@example.com")
+		raceName := builder.CreateString("Pilot Nova")
+		preferredLanguage := builder.CreateString("en")
+		timeZone := builder.CreateString("Europe/Kaliningrad")
+
+		userfbs.AccountViewStart(builder)
+		userfbs.AccountViewAddUserId(builder, userID)
+		userfbs.AccountViewAddEmail(builder, email)
+		userfbs.AccountViewAddRaceName(builder, raceName)
+		userfbs.AccountViewAddPreferredLanguage(builder, preferredLanguage)
+		userfbs.AccountViewAddTimeZone(builder, timeZone)
+		userfbs.AccountViewAddEntitlement(builder, entitlementOffset)
+		userfbs.AccountViewAddActiveLimits(builder, limitsVector)
+		userfbs.AccountViewAddCreatedAtMs(builder, nowMS)
+		userfbs.AccountViewAddUpdatedAtMs(builder, nowMS)
+		return userfbs.AccountViewEnd(builder)
+	})
+
+	_, err := PayloadToAccountResponse(payload)
+	if err == nil {
+		t.Fatal("expected overflow error")
+	}
+	if !strings.Contains(err.Error(), "overflows int") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPayloadToErrorResponseRejectsMissingError(t *testing.T) {
+	t.Parallel()
+
+	builder := flatbuffers.NewBuilder(64)
+	userfbs.ErrorResponseStart(builder)
+	offset := userfbs.ErrorResponseEnd(builder)
+	userfbs.FinishErrorResponseBuffer(builder, offset)
+
+	_, err := PayloadToErrorResponse(builder.FinishedBytes())
+	if err == nil {
+		t.Fatal("expected error for missing error body")
+	}
+	if !strings.Contains(err.Error(), "error is missing") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func buildAccountResponsePayload(accountBuilder func(*flatbuffers.Builder) flatbuffers.UOffsetT) []byte {
+	builder := flatbuffers.NewBuilder(256)
+
+	accountOffset := accountBuilder(builder)
+
+	userfbs.AccountResponseStart(builder)
+	userfbs.AccountResponseAddAccount(builder, accountOffset)
+	responseOffset := userfbs.AccountResponseEnd(builder)
+	userfbs.FinishAccountResponseBuffer(builder, responseOffset)
+
+	return builder.FinishedBytes()
+}