Move relayer FeeQuote and binary utils to go-sequence (#289)

* Move relayer FeeQuote to go-sequence

* Move write*() binary utility functions into its own lib/binaryutil pkg

* Write unit tests for binaryutil pkg

Author: VojtechVitek

lib/binaryutil/bigint.go

@@ -0,0 +1,37 @@
+package binaryutil
+
+import (
+	"encoding/binary"
+	"io"
+	"math/big"
+)
+
+func WriteOptionalBigInt(w io.Writer, n *big.Int) error {
+	err := binary.Write(w, binary.LittleEndian, n != nil)
+	if err != nil {
+		return err
+	}
+
+	if n != nil {
+		err = WriteBigInt(w, n)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func WriteBigInt(w io.Writer, n *big.Int) error {
+	err := binary.Write(w, binary.LittleEndian, int8(n.Sign()))
+	if err != nil {
+		return err
+	}
+
+	_, err = w.Write(n.Bytes())
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

lib/binaryutil/bigint_test.go

@@ -0,0 +1,86 @@
+package binaryutil
+
+import (
+	"bytes"
+	"math/big"
+	"testing"
+)
+
+func TestWriteBigInt(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    *big.Int
+		expected []byte
+	}{
+		{
+			name:     "positive",
+			input:    big.NewInt(12345),
+			expected: append([]byte{0x01}, big.NewInt(12345).Bytes()...),
+		},
+		{
+			name:     "negative",
+			input:    big.NewInt(-12345),
+			expected: append([]byte{0xFF}, big.NewInt(12345).Bytes()...),
+		},
+		{
+			name:     "zero",
+			input:    big.NewInt(0),
+			expected: []byte{0x00},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			err := WriteBigInt(&buf, tt.input)
+			if err != nil {
+				t.Fatalf("WriteBigInt() error = %v", err)
+			}
+			if !bytes.Equal(buf.Bytes(), tt.expected) {
+				t.Errorf("WriteBigInt() = %v, want %v", buf.Bytes(), tt.expected)
+			}
+		})
+	}
+}
+
+func TestWriteOptionalBigInt(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    *big.Int
+		expected []byte
+	}{
+		{
+			name:     "nil",
+			input:    nil,
+			expected: []byte{0x00},
+		},
+		{
+			name:     "positive",
+			input:    big.NewInt(12345),
+			expected: append([]byte{0x01}, append([]byte{0x01}, big.NewInt(12345).Bytes()...)...),
+		},
+		{
+			name:     "negative",
+			input:    big.NewInt(-12345),
+			expected: append([]byte{0x01}, append([]byte{0xFF}, big.NewInt(12345).Bytes()...)...),
+		},
+		{
+			name:     "zero",
+			input:    big.NewInt(0),
+			expected: append([]byte{0x01}, []byte{0x00}...),
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			err := WriteOptionalBigInt(&buf, tt.input)
+			if err != nil {
+				t.Fatalf("WriteOptionalBigInt() error = %v", err)
+			}
+			if !bytes.Equal(buf.Bytes(), tt.expected) {
+				t.Errorf("WriteOptionalBigInt() = %v, want %v", buf.Bytes(), tt.expected)
+			}
+		})
+	}
+}

lib/binaryutil/uint.go

@@ -0,0 +1,22 @@
+package binaryutil
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+func WriteOptionalUint64(w io.Writer, n *uint64) error {
+	err := binary.Write(w, binary.LittleEndian, n != nil)
+	if err != nil {
+		return err
+	}
+
+	if n != nil {
+		err = binary.Write(w, binary.LittleEndian, *n)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

lib/binaryutil/uint_test.go

@@ -0,0 +1,38 @@
+package binaryutil
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestWriteOptionalUint64(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    *uint64
+		expected []byte
+	}{
+		{
+			name:     "nil",
+			input:    nil,
+			expected: []byte{0x00},
+		},
+		{
+			name:     "present",
+			input:    func() *uint64 { v := uint64(12345); return &v }(),
+			expected: []byte{0x01, 0x39, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			err := WriteOptionalUint64(&buf, tt.input)
+			if err != nil {
+				t.Fatalf("WriteOptionalUint64() error = %v", err)
+			}
+			if !bytes.Equal(buf.Bytes(), tt.expected) {
+				t.Errorf("WriteOptionalUint64() = %v, want %v", buf.Bytes(), tt.expected)
+			}
+		})
+	}
+}

relayer/quote.go

@@ -0,0 +1,136 @@
+package relayer
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+	"math/big"
+	"sort"
+	"time"
+
+	"github.com/0xsequence/ethkit/ethwallet"
+	"github.com/0xsequence/ethkit/go-ethereum/common"
+	"github.com/0xsequence/go-sequence/lib/binaryutil"
+)
+
+type FeeQuote struct {
+	TransactionDigest common.Hash
+	IsWhitelisted     bool
+	GasSponsor        *uint64
+	GasTank           *uint64
+	GasUsage          *uint64
+	GasPrice          *big.Int
+	NativePrice       *big.Int
+	TokenPrices       map[string]*big.Int
+	ExpiresAt         *time.Time
+	Signature         []byte
+}
+
+func (q *FeeQuote) Sign(wallet *ethwallet.Wallet, validFor time.Duration) error {
+	expiresAt := time.Now().Add(validFor)
+	q.ExpiresAt = &expiresAt
+
+	message, err := q.message()
+	if err != nil {
+		return err
+	}
+
+	q.Signature, err = wallet.SignMessage(message)
+	return err
+}
+
+func (q *FeeQuote) Verify(wallet *ethwallet.Wallet) error {
+	return q.VerifySignedBy(wallet.Address())
+}
+
+// VerifySignedBy verifies the quote against one or more expected signer addresses
+func (q *FeeQuote) VerifySignedBy(expectedAddresses ...common.Address) error {
+	if q.ExpiresAt.Before(time.Now()) {
+		return fmt.Errorf("quote expired")
+	}
+
+	message, err := q.message()
+	if err != nil {
+		return err
+	}
+
+	address, err := ethwallet.RecoverAddress(message, q.Signature)
+	if err != nil {
+		return err
+	}
+
+	for _, expected := range expectedAddresses {
+		if address == expected {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("quote signed by unexpected address %s", address.Hex())
+}
+
+func (q *FeeQuote) message() ([]byte, error) {
+	if q.ExpiresAt == nil {
+		return nil, fmt.Errorf("missing expiration date")
+	}
+
+	var message bytes.Buffer
+
+	_, err := message.Write(q.TransactionDigest.Bytes())
+	if err != nil {
+		return nil, err
+	}
+
+	err = binary.Write(&message, binary.LittleEndian, q.IsWhitelisted)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binaryutil.WriteOptionalUint64(&message, q.GasSponsor)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binaryutil.WriteOptionalUint64(&message, q.GasTank)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binaryutil.WriteOptionalUint64(&message, q.GasUsage)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binaryutil.WriteOptionalBigInt(&message, q.GasPrice)
+	if err != nil {
+		return nil, err
+	}
+
+	err = binaryutil.WriteOptionalBigInt(&message, q.NativePrice)
+	if err != nil {
+		return nil, err
+	}
+
+	tokens := make([]string, 0, len(q.TokenPrices))
+	for token := range q.TokenPrices {
+		tokens = append(tokens, token)
+	}
+	sort.Strings(tokens)
+	for _, token := range tokens {
+		_, err = message.WriteString(token)
+		if err != nil {
+			return nil, err
+		}
+
+		err = binaryutil.WriteBigInt(&message, q.TokenPrices[token])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = binary.Write(&message, binary.LittleEndian, q.ExpiresAt.Unix())
+	if err != nil {
+		return nil, err
+	}
+
+	return message.Bytes(), nil
+}