initial

accounting/types.go

@@ -0,0 +1,353 @@
+package accounting
+
+import (
+	"crypto/ecdsa"
+	"crypto/rand"
+	"encoding/binary"
+	"reflect"
+
+	"github.com/mr-tron/base58"
+	crypto "github.com/nspcc-dev/neofs-crypto"
+	"github.com/nspcc-dev/neofs-proto/chain"
+	"github.com/nspcc-dev/neofs-proto/decimal"
+	"github.com/nspcc-dev/neofs-proto/internal"
+	"github.com/nspcc-dev/neofs-proto/refs"
+	"github.com/pkg/errors"
+)
+
+type (
+	// Cheque structure that describes a user request for withdrawal of funds.
+	Cheque struct {
+		ID         ChequeID
+		Owner      refs.OwnerID
+		Amount     *decimal.Decimal
+		Height     uint64
+		Signatures []ChequeSignature
+	}
+
+	// BalanceReceiver interface that is used to retrieve user balance by address.
+	BalanceReceiver interface {
+		Balance(accountAddress string) (*Account, error)
+	}
+
+	// ChequeID is identifier of user request for withdrawal of funds.
+	ChequeID string
+
+	// CID type alias.
+	CID = refs.CID
+
+	// SGID type alias.
+	SGID = refs.SGID
+
+	// ChequeSignature contains public key and hash, and is used to verify signatures.
+	ChequeSignature struct {
+		Key  *ecdsa.PublicKey
+		Hash []byte
+	}
+)
+
+const (
+	// ErrWrongSignature is raised when wrong signature is passed.
+	ErrWrongSignature = internal.Error("wrong signature")
+
+	// ErrWrongPublicKey is raised when wrong public key is passed.
+	ErrWrongPublicKey = internal.Error("wrong public key")
+
+	// ErrWrongChequeData is raised when passed bytes cannot not be parsed as valid Cheque.
+	ErrWrongChequeData = internal.Error("wrong cheque data")
+
+	// ErrInvalidLength is raised when passed bytes cannot not be parsed as valid ChequeID.
+	ErrInvalidLength = internal.Error("invalid length")
+
+	u16size = 2
+	u64size = 8
+
+	signaturesOffset = chain.AddressLength + refs.OwnerIDSize + u64size + u64size
+)
+
+// NewChequeID generates valid random ChequeID using crypto/rand.Reader.
+func NewChequeID() (ChequeID, error) {
+	d := make([]byte, chain.AddressLength)
+	if _, err := rand.Read(d); err != nil {
+		return "", err
+	}
+
+	id := base58.Encode(d)
+
+	return ChequeID(id), nil
+}
+
+// String returns string representation of ChequeID.
+func (b ChequeID) String() string { return string(b) }
+
+// Empty returns true, if ChequeID is empty.
+func (b ChequeID) Empty() bool { return len(b) == 0 }
+
+// Valid validates ChequeID.
+func (b ChequeID) Valid() bool {
+	d, err := base58.Decode(string(b))
+	return err == nil && len(d) == chain.AddressLength
+}
+
+// Bytes returns bytes representation of ChequeID.
+func (b ChequeID) Bytes() []byte {
+	d, err := base58.Decode(string(b))
+	if err != nil {
+		return make([]byte, chain.AddressLength)
+	}
+	return d
+}
+
+// Equal checks that current ChequeID is equal to passed ChequeID.
+func (b ChequeID) Equal(b2 ChequeID) bool {
+	return b.Valid() && b2.Valid() && string(b) == string(b2)
+}
+
+// Unmarshal tries to parse []byte into valid ChequeID.
+func (b *ChequeID) Unmarshal(data []byte) error {
+	*b = ChequeID(base58.Encode(data))
+	if !b.Valid() {
+		return ErrInvalidLength
+	}
+	return nil
+}
+
+// Size returns size (chain.AddressLength).
+func (b ChequeID) Size() int {
+	return chain.AddressLength
+}
+
+// MarshalTo tries to marshal ChequeID into passed bytes and returns
+// count of copied bytes or error, if bytes len is not enough to contain ChequeID.
+func (b ChequeID) MarshalTo(data []byte) (int, error) {
+	if len(data) < chain.AddressLength {
+		return 0, ErrInvalidLength
+	}
+	return copy(data, b.Bytes()), nil
+}
+
+// Equals checks that m and tx are valid and equal Tx values.
+func (m Tx) Equals(tx Tx) bool {
+	return m.From == tx.From &&
+		m.To == tx.To &&
+		m.Type == tx.Type &&
+		m.Amount == tx.Amount
+}
+
+// Verify validates current Cheque and Signatures that are generated for current Cheque.
+func (b Cheque) Verify() error {
+	data := b.marshalBody()
+	for i, sign := range b.Signatures {
+		if err := crypto.VerifyRFC6979(sign.Key, data, sign.Hash); err != nil {
+			return errors.Wrapf(ErrWrongSignature, "item #%d: %s", i, err.Error())
+		}
+	}
+
+	return nil
+}
+
+// Sign is used to sign current Cheque and stores result inside b.Signatures.
+func (b *Cheque) Sign(key *ecdsa.PrivateKey) error {
+	hash, err := crypto.SignRFC6979(key, b.marshalBody())
+	if err != nil {
+		return err
+	}
+
+	b.Signatures = append(b.Signatures, ChequeSignature{
+		Key:  &key.PublicKey,
+		Hash: hash,
+	})
+
+	return nil
+}
+
+func (b *Cheque) marshalBody() []byte {
+	buf := make([]byte, signaturesOffset)
+
+	var offset int
+
+	offset += copy(buf, b.ID.Bytes())
+	offset += copy(buf[offset:], b.Owner.Bytes())
+
+	binary.BigEndian.PutUint64(buf[offset:], uint64(b.Amount.Value))
+	offset += u64size
+
+	binary.BigEndian.PutUint64(buf[offset:], b.Height)
+
+	return buf
+}
+
+func (b *Cheque) unmarshalBody(buf []byte) error {
+	var offset int
+
+	if len(buf) < signaturesOffset {
+		return ErrWrongChequeData
+	}
+
+	{ // unmarshal UUID
+		if err := b.ID.Unmarshal(buf[offset : offset+chain.AddressLength]); err != nil {
+			return err
+		}
+		offset += chain.AddressLength
+	}
+
+	{ // unmarshal OwnerID
+		if err := b.Owner.Unmarshal(buf[offset : offset+refs.OwnerIDSize]); err != nil {
+			return err
+		}
+		offset += refs.OwnerIDSize
+	}
+
+	{ // unmarshal amount
+		amount := int64(binary.BigEndian.Uint64(buf[offset:]))
+		b.Amount = decimal.New(amount)
+		offset += u64size
+	}
+
+	{ // unmarshal height
+		b.Height = binary.BigEndian.Uint64(buf[offset:])
+		offset += u64size
+	}
+
+	return nil
+}
+
+// MarshalBinary is used to marshal Cheque into bytes.
+func (b Cheque) MarshalBinary() ([]byte, error) {
+	var (
+		count  = len(b.Signatures)
+		buf    = make([]byte, b.Size())
+		offset = copy(buf, b.marshalBody())
+	)
+
+	binary.BigEndian.PutUint16(buf[offset:], uint16(count))
+	offset += u16size
+
+	for _, sign := range b.Signatures {
+		key := crypto.MarshalPublicKey(sign.Key)
+		offset += copy(buf[offset:], key)
+		offset += copy(buf[offset:], sign.Hash)
+	}
+
+	return buf, nil
+}
+
+// Size returns size of Cheque (count of bytes needs to store it).
+func (b Cheque) Size() int {
+	return signaturesOffset + u16size +
+		len(b.Signatures)*(crypto.PublicKeyCompressedSize+crypto.RFC6979SignatureSize)
+}
+
+// UnmarshalBinary tries to parse []byte into valid Cheque.
+func (b *Cheque) UnmarshalBinary(buf []byte) error {
+	if err := b.unmarshalBody(buf); err != nil {
+		return err
+	}
+
+	body := buf[:signaturesOffset]
+
+	count := int64(binary.BigEndian.Uint16(buf[signaturesOffset:]))
+	offset := signaturesOffset + u16size
+
+	if ln := count * int64(crypto.PublicKeyCompressedSize+crypto.RFC6979SignatureSize); ln > int64(len(buf[offset:])) {
+		return ErrWrongChequeData
+	}
+
+	for i := int64(0); i < count; i++ {
+		sign := ChequeSignature{
+			Key:  crypto.UnmarshalPublicKey(buf[offset : offset+crypto.PublicKeyCompressedSize]),
+			Hash: make([]byte, crypto.RFC6979SignatureSize),
+		}
+
+		offset += crypto.PublicKeyCompressedSize
+		if sign.Key == nil {
+			return errors.Wrapf(ErrWrongPublicKey, "item #%d", i)
+		}
+
+		offset += copy(sign.Hash, buf[offset:offset+crypto.RFC6979SignatureSize])
+		if err := crypto.VerifyRFC6979(sign.Key, body, sign.Hash); err != nil {
+			return errors.Wrapf(ErrWrongSignature, "item #%d: %s (offset=%d, len=%d)", i, err.Error(), offset, len(sign.Hash))
+		}
+
+		b.Signatures = append(b.Signatures, sign)
+	}
+
+	return nil
+}
+
+// ErrNotEnoughFunds generates error using address and amounts.
+func ErrNotEnoughFunds(addr string, needed, residue *decimal.Decimal) error {
+	return errors.Errorf("not enough funds (requested=%s, residue=%s, addr=%s", needed, residue, addr)
+}
+
+func (m *Account) hasLockAcc(addr string) bool {
+	for i := range m.LockAccounts {
+		if m.LockAccounts[i].Address == addr {
+			return true
+		}
+	}
+	return false
+}
+
+// ValidateLock checks that account can be locked.
+func (m *Account) ValidateLock() error {
+	switch {
+	case m.Address == "":
+		return ErrEmptyAddress
+	case m.ParentAddress == "":
+		return ErrEmptyParentAddress
+	case m.LockTarget == nil:
+		return ErrEmptyLockTarget
+	}
+
+	switch v := m.LockTarget.Target.(type) {
+	case *LockTarget_WithdrawTarget:
+		if v.WithdrawTarget.Cheque != m.Address {
+			return errors.Errorf("wrong cheque ID: expected %s, has %s", m.Address, v.WithdrawTarget.Cheque)
+		}
+	case *LockTarget_ContainerCreateTarget:
+		switch {
+		case v.ContainerCreateTarget.CID.Empty():
+			return ErrEmptyContainerID
+		}
+	}
+	return nil
+}
+
+// CanLock checks possibility to lock funds.
+func (m *Account) CanLock(lockAcc *Account) error {
+	switch {
+	case m.ActiveFunds.LT(lockAcc.ActiveFunds):
+		return ErrNotEnoughFunds(lockAcc.ParentAddress, lockAcc.ActiveFunds, m.ActiveFunds)
+	case m.hasLockAcc(lockAcc.Address):
+		return errors.Errorf("could not lock account(%s) funds: duplicating lock(%s)", m.Address, lockAcc.Address)
+	default:
+		return nil
+	}
+}
+
+// LockForWithdraw checks that account contains locked funds by passed ChequeID.
+func (m *Account) LockForWithdraw(chequeID string) bool {
+	switch v := m.LockTarget.Target.(type) {
+	case *LockTarget_WithdrawTarget:
+		return v.WithdrawTarget.Cheque == chequeID
+	}
+	return false
+}
+
+// LockForContainerCreate checks that account contains locked funds for container creation.
+func (m *Account) LockForContainerCreate(cid refs.CID) bool {
+	switch v := m.LockTarget.Target.(type) {
+	case *LockTarget_ContainerCreateTarget:
+		return v.ContainerCreateTarget.CID.Equal(cid)
+	}
+	return false
+}
+
+// Equal checks that current Settlement is equal to passed Settlement.
+func (m *Settlement) Equal(s *Settlement) bool {
+	if s == nil || m.Epoch != s.Epoch || len(m.Transactions) != len(s.Transactions) {
+		return false
+	}
+	return len(m.Transactions) == 0 || reflect.DeepEqual(m.Transactions, s.Transactions)
+}