WIP

Signed-off-by: Leonard Lyubich <leonard@morphbits.io>

accounting/decimal.go

@@ -1,93 +1,97 @@
 package accounting
 
 import (
-	"github.com/nspcc-dev/neofs-api-go/v2/accounting"
+	"github.com/nspcc-dev/neofs-sdk-go/api/accounting"
+	"google.golang.org/protobuf/proto"
 )
 
 // Decimal represents decimal number for accounting operations.
 //
-// Decimal is mutually compatible with github.com/nspcc-dev/neofs-api-go/v2/accounting.Decimal
-// message. See ReadFromV2 / WriteToV2 methods.
+// Decimal is mutually compatible with [accounting.Decimal] message. See
+// [Decimal.ReadFromV2] / [Decimal.WriteToV2] methods.
 //
 // Instances can be created using built-in var declaration.
-//
-// Note that direct typecast is not safe and may result in loss of compatibility:
-//
-//	_ = Decimal(accounting.Decimal{}) // not recommended
-type Decimal accounting.Decimal
+type Decimal struct {
+	val  int64
+	prec uint32
+}
 
-// ReadFromV2 reads Decimal from the accounting.Decimal message. Checks if the
-// message conforms to NeoFS API V2 protocol.
+// ReadFromV2 reads Decimal from the [accounting.Decimal] message. Checks if the
+// message conforms to NeoFS API V2 protocol. The message must not be nil.
 //
-// See also WriteToV2.
-func (d *Decimal) ReadFromV2(m accounting.Decimal) error {
-	*d = Decimal(m)
+// See also [Decimal.WriteToV2].
+func (d *Decimal) ReadFromV2(m *accounting.Decimal) error {
+	d.val = m.Value
+	d.prec = m.Precision
 	return nil
 }
 
-// WriteToV2 writes Decimal to the accounting.Decimal message.
-// The message must not be nil.
+// WriteToV2 writes Decimal to the [accounting.Decimal] message. The message
+// must not be nil.
 //
-// See also ReadFromV2.
+// See also [Decimal.ReadFromV2].
 func (d Decimal) WriteToV2(m *accounting.Decimal) {
-	*m = (accounting.Decimal)(d)
+	m.Value = d.val
+	m.Precision = d.prec
 }
 
 // Value returns value of the decimal number.
 //
 // Zero Decimal has zero value.
 //
-// See also SetValue.
+// See also [Decimal.SetValue].
 func (d Decimal) Value() int64 {
-	return (*accounting.Decimal)(&d).GetValue()
+	return d.val
 }
 
 // SetValue sets value of the decimal number.
 //
-// See also Value.
+// See also [Decimal.Value].
 func (d *Decimal) SetValue(v int64) {
-	(*accounting.Decimal)(d).SetValue(v)
+	d.val = v
 }
 
 // Precision returns precision of the decimal number.
 //
 // Zero Decimal has zero precision.
 //
-// See also SetPrecision.
+// See also [Decimal.SetPrecision].
 func (d Decimal) Precision() uint32 {
-	return (*accounting.Decimal)(&d).GetPrecision()
+	return d.prec
 }
 
 // SetPrecision sets precision of the decimal number.
 //
-// See also Precision.
+// See also [Decimal.Precision].
 func (d *Decimal) SetPrecision(p uint32) {
-	(*accounting.Decimal)(d).SetPrecision(p)
+	d.prec = p
 }
 
 // Marshal encodes Decimal into a binary format of the NeoFS API protocol
 // (Protocol Buffers with direct field order).
 //
-// See also Unmarshal.
+// See also [Decimal.Unmarshal].
 func (d Decimal) Marshal() []byte {
 	var m accounting.Decimal
 	d.WriteToV2(&m)
 
-	return m.StableMarshal(nil)
+	b := make([]byte, m.MarshaledSize())
+	m.MarshalStable(b)
+	return b
 }
 
 // Unmarshal decodes NeoFS API protocol binary format into the Decimal
 // (Protocol Buffers with direct field order). Returns an error describing
 // a format violation.
 //
-// See also Marshal.
+// See also [Decimal.Marshal].
 func (d *Decimal) Unmarshal(data []byte) error {
 	var m accounting.Decimal
 
-	err := m.Unmarshal(data)
+	err := proto.Unmarshal(data, &m)
 	if err != nil {
 		return err
 	}
 
-	return d.ReadFromV2(m)
+	return d.ReadFromV2(&m)
 }

accounting/decimal_test.go

@@ -3,9 +3,9 @@ package accounting_test
 import (
 	"testing"
 
-	v2accounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
 	"github.com/nspcc-dev/neofs-sdk-go/accounting"
 	accountingtest "github.com/nspcc-dev/neofs-sdk-go/accounting/test"
+	apiaccounting "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
 	"github.com/stretchr/testify/require"
 )
 
@@ -25,25 +25,20 @@ func TestDecimalData(t *testing.T) {
 }
 
 func TestDecimalMessageV2(t *testing.T) {
-	var (
-		d accounting.Decimal
-		m v2accounting.Decimal
-	)
-
-	m.SetValue(7)
-	m.SetPrecision(8)
+	m := &apiaccounting.Decimal{Value: 7, Precision: 8}
 
+	var d accounting.Decimal
 	require.NoError(t, d.ReadFromV2(m))
 
-	require.EqualValues(t, m.GetValue(), d.Value())
-	require.EqualValues(t, m.GetPrecision(), d.Precision())
+	require.EqualValues(t, 7, d.Value())
+	require.EqualValues(t, 8, d.Precision())
 
-	var m2 v2accounting.Decimal
+	var m2 apiaccounting.Decimal
 
 	d.WriteToV2(&m2)
 
-	require.EqualValues(t, d.Value(), m2.GetValue())
-	require.EqualValues(t, d.Precision(), m2.GetPrecision())
+	require.EqualValues(t, 7, m2.GetValue())
+	require.EqualValues(t, 8, m2.GetPrecision())
 }
 
 func TestDecimal_Marshal(t *testing.T) {

accounting/example_test.go

@@ -1,8 +1,8 @@
 package accounting_test
 
 import (
-	apiGoAccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
 	"github.com/nspcc-dev/neofs-sdk-go/accounting"
+	apiaccounting "github.com/nspcc-dev/neofs-sdk-go/api/accounting"
 )
 
 func Example() {
@@ -16,11 +16,10 @@ func Example() {
 
 	// On the client side.
 
-	// import apiGoAccounting "github.com/nspcc-dev/neofs-api-go/v2/accounting"
-	var msg apiGoAccounting.Decimal
+	var msg apiaccounting.Decimal
 	dec.WriteToV2(&msg)
 	// *send message*
 
 	// On the server side.
-	_ = dec.ReadFromV2(msg)
+	_ = dec.ReadFromV2(&msg)
 }

api/accounting/encoding.go

@@ -0,0 +1,65 @@
+package accounting
+
+import (
+	"github.com/nspcc-dev/neofs-sdk-go/internal/proto"
+)
+
+const (
+	_ = iota
+	fieldDecimalValue
+	fieldDecimalPrecision
+)
+
+func (x *Decimal) MarshaledSize() int {
+	var sz int
+	if x != nil {
+		sz = proto.SizeVarint(fieldDecimalValue, x.Value) +
+			proto.SizeVarint(fieldDecimalPrecision, x.Precision)
+	}
+	return sz
+}
+
+func (x *Decimal) MarshalStable(b []byte) {
+	if x != nil {
+		off := proto.MarshalVarint(b, fieldDecimalValue, x.Value)
+		proto.MarshalVarint(b[off:], fieldDecimalPrecision, x.Precision)
+	}
+}
+
+const (
+	_ = iota
+	fieldBalanceReqOwner
+)
+
+func (x *BalanceRequest_Body) MarshaledSize() int {
+	var sz int
+	if x != nil {
+		sz = proto.SizeNested(fieldBalanceReqOwner, x.OwnerId)
+	}
+	return sz
+}
+
+func (x *BalanceRequest_Body) MarshalStable(b []byte) {
+	if x != nil {
+		proto.MarshalNested(b, fieldBalanceReqOwner, x.OwnerId)
+	}
+}
+
+const (
+	_ = iota
+	fieldBalanceRespBalance
+)
+
+func (x *BalanceResponse_Body) MarshaledSize() int {
+	var sz int
+	if x != nil {
+		sz = proto.SizeNested(fieldBalanceRespBalance, x.Balance)
+	}
+	return sz
+}
+
+func (x *BalanceResponse_Body) MarshalStable(b []byte) {
+	if x != nil {
+		proto.MarshalNested(b, fieldBalanceRespBalance, x.Balance)
+	}
+}

api/accounting/encoding_test.go

@@ -0,0 +1,49 @@
+package accounting_test
+
+import (
+	"testing"
+
+	"github.com/nspcc-dev/neofs-sdk-go/api/accounting"
+	"github.com/nspcc-dev/neofs-sdk-go/api/refs"
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+)
+
+func TestBalanceRequest_Body(t *testing.T) {
+	v := &accounting.BalanceRequest_Body{
+		OwnerId: &refs.OwnerID{
+			Value: []byte("any_owner"),
+		},
+	}
+
+	sz := v.MarshaledSize()
+	b := make([]byte, sz)
+	v.MarshalStable(b)
+
+	var res accounting.BalanceRequest_Body
+	err := proto.Unmarshal(b, &res)
+	require.NoError(t, err)
+	require.Empty(t, res.ProtoReflect().GetUnknown())
+	require.Equal(t, v.OwnerId, res.OwnerId)
+	// TODO: test field order. Pretty challenging in general, but can be simplified
+	//  for NeoFS specifics (forbid group types, maps, etc.).
+}
+
+func TestBalanceResponse_Body(t *testing.T) {
+	v := &accounting.BalanceResponse_Body{
+		Balance: &accounting.Decimal{
+			Value:     12,
+			Precision: 34,
+		},
+	}
+
+	sz := v.MarshaledSize()
+	b := make([]byte, sz)
+	v.MarshalStable(b)
+
+	var res accounting.BalanceResponse_Body
+	err := proto.Unmarshal(b, &res)
+	require.NoError(t, err)
+	require.Empty(t, res.ProtoReflect().GetUnknown())
+	require.Equal(t, v.Balance, res.Balance)
+}