[chain] Address Refactor

chain/dependencies.go

@@ -288,7 +288,7 @@ type Auth interface {
 
 	// Payer is the owner of [Auth]. It is used by the mempool to ensure that there aren't too many transactions
 	// from a single Payer.
-	Payer() []byte
+	Payer() codec.ShortBytes
 
 	// CanDeduct returns an error if [amount] cannot be paid by [Auth].
 	CanDeduct(ctx context.Context, im state.Immutable, amount uint64) error

cli/key.go

@@ -33,7 +33,7 @@
 }
 
 func (h *Handler) ImportKey(keyPath string) error {
-	priv, err := ed25519.LoadKey(keyPath)
+	priv, err := utils.LoadKey(keyPath)
 	if err != nil {
 		return err
 	}

codec/address.go

@@ -0,0 +1,82 @@
+package codec
+
+import (
+	"fmt"
+
+	"github.com/ava-labs/avalanchego/utils/formatting/address"
+)
+
+const (
+	fromBits      = 8
+	toBits        = 5
+	separatorLen  = 1
+	checksumlen   = 6
+	maxBech32Size = 90
+)
+
+// Address returns a Bech32 address from hrp and p.
+// This function uses avalanchego's FormatBech32 function.
+func Address(hrp string, p ShortBytes) (string, error) {
+	if !p.Valid() {
+		return "", ErrInvalidShortBytes
+	}
+	expanedNum := p.Len() * fromBits
+	expandedLen := expanedNum / toBits
+	if expanedNum%toBits != 0 {
+		expandedLen++
+	}
+	addrLen := len(hrp) + separatorLen + expandedLen + checksumlen
+	if addrLen > maxBech32Size {
+		return "", fmt.Errorf("%w: max=%d, requested=%d", ErrInvalidSize, maxBech32Size, addrLen)
+	}
+	return address.FormatBech32(hrp, p[:])
+}
+
+// ParseAddress parses a Bech32 encoded address string and extracts
+// its bytes (ensuring they are of size [length]). If there is an error
+// reading the address or the hrp value is not valid, ParseAddress returns an error.
+func ParseAddress(hrp, saddr string, length int) (ShortBytes, error) {
+	if length > ShortBytesMaxSize {
+		return nil, ErrInvalidShortBytes
+	}
+	phrp, p, err := address.ParseBech32(saddr)
+	if err != nil {
+		return nil, err
+	}
+	if phrp != hrp {
+		return nil, ErrIncorrectHRP
+	}
+	// The parsed value may be greater than [minLength] because the
+	// underlying Bech32 implementation requires bytes to each encode 5 bits
+	// instead of 8 (and we must pad the input to ensure we fill all bytes):
+	// https://github.com/btcsuite/btcd/blob/902f797b0c4b3af3f7196d2f5d2343931d1b2bdf/btcutil/bech32/bech32.go#L325-L331
+	if len(p) < length {
+		return nil, ErrInsufficientLength
+	}
+	return p[:length], nil
+}
+
+// ParseAnyAddress parses a Bech32 encoded address string and extracts
+// its bytes. If there is an error reading the address or the hrp value
+// is not valid, ParseAnyAddress returns an error.
+//
+// The ShortBytes returned may contain extra padding. If the parsed
+// length is greater than [ShortBytesMaxSize], it is truncated (should
+// not be possible because max string length is 90).
+func ParseAnyAddress(hrp, saddr string) (ShortBytes, error) {
+	phrp, p, err := address.ParseBech32(saddr)
+	if err != nil {
+		return nil, err
+	}
+	if phrp != hrp {
+		return nil, ErrIncorrectHRP
+	}
+	// The parsed value may be greater than [ShortBytesMaxSize] because the
+	// underlying Bech32 implementation requires bytes to each encode 5 bits
+	// instead of 8 (and we must pad the input to ensure we fill all bytes):
+	// https://github.com/btcsuite/btcd/blob/902f797b0c4b3af3f7196d2f5d2343931d1b2bdf/btcutil/bech32/bech32.go#L325-L331
+	if len(p) > ShortBytesMaxSize {
+		p = p[:ShortBytesMaxSize]
+	}
+	return p, nil
+}

codec/address_test.go

@@ -0,0 +1,71 @@
+package codec
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/stretchr/testify/require"
+)
+
+const hrp = "blah"
+
+func TestIDAddress(t *testing.T) {
+	require := require.New(t)
+
+	id := ids.GenerateTestID()
+	addr, err := Address(hrp, id[:])
+	require.NoError(err)
+
+	sb, err := ParseAddress(hrp, addr, ids.IDLen)
+	require.NoError(err)
+	require.True(bytes.Equal(id[:], sb[:]))
+}
+
+func TestInvalidAddressHRP(t *testing.T) {
+	require := require.New(t)
+	addr := "blah1859dz2uwazfgahey3j53ef2kqrans0c8cv4l78tda3rjkfw0txns8u2e8k"
+
+	_, err := ParseAddress("test", addr, ids.IDLen)
+	require.ErrorIs(err, ErrIncorrectHRP)
+}
+
+func TestInvalidAddressChecksum(t *testing.T) {
+	require := require.New(t)
+	addr := "blah1859dz2uwazfgahey3j53ef2kqrans0c8cv4l78tda3rjkfw0txns8u2e7k"
+
+	_, err := ParseAddress(hrp, addr, ids.IDLen)
+	require.ErrorContains(err, "invalid checksum")
+}
+
+func TestMaxAddress(t *testing.T) {
+	require := require.New(t)
+
+	b := make([]byte, 49)
+	b[0] = 1
+	b[49-1] = 1
+	addr, err := Address(hrp, b)
+	require.NoError(err)
+
+	sb, err := ParseAddress(hrp, addr, 49)
+	require.NoError(err)
+	require.True(bytes.Equal(b[:], sb[:]))
+}
+
+func TestCreateLargeAddress(t *testing.T) {
+	require := require.New(t)
+
+	b := make([]byte, 50)
+	b[0] = 1
+	b[50-1] = 1
+	_, err := Address(hrp, b)
+	require.ErrorIs(err, ErrInvalidSize)
+}
+
+func TestParseLargeAddress(t *testing.T) {
+	require := require.New(t)
+
+	addr := "blah1859dz2uwazfgahey3j53ef2kqrans0c8cv4l78tda3rjkfw0txnxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxs8u2e7k"
+	_, err := ParseAddress(hrp, addr, 60)
+	require.ErrorContains(err, "invalid bech32 string length")
+}

codec/errors.go

@@ -6,9 +6,12 @@ package codec
 import "errors"
 
 var (
-	ErrTooManyItems      = errors.New("too many items")
-	ErrDuplicateItem     = errors.New("duplicate item")
-	ErrFieldNotPopulated = errors.New("field is not populated")
-	ErrInvalidBitset     = errors.New("invalid bitset")
-	ErrTooLarge          = errors.New("too large")
+	ErrTooManyItems       = errors.New("too many items")
+	ErrDuplicateItem      = errors.New("duplicate item")
+	ErrFieldNotPopulated  = errors.New("field is not populated")
+	ErrInvalidBitset      = errors.New("invalid bitset")
+	ErrInvalidShortBytes  = errors.New("invalid short bytes")
+	ErrIncorrectHRP       = errors.New("incorrect hrp")
+	ErrInsufficientLength = errors.New("insufficient length")
+	ErrInvalidSize        = errors.New("invalid size")
 )

codec/hex.go

@@ -0,0 +1,21 @@
+package codec
+
+import "encoding/hex"
+
+// ToHex converts a PrivateKey to a hex string.
+func ToHex(b []byte) string {
+	return hex.EncodeToString(b[:])
+}
+
+// LoadHex Converts hex encoded string into bytes. Returns
+// an error if key is invalid.
+func LoadHex(s string, expectedSize int) ([]byte, error) {
+	bytes, err := hex.DecodeString(s)
+	if err != nil {
+		return nil, err
+	}
+	if expectedSize != -1 && len(bytes) != expectedSize {
+		return nil, ErrInvalidSize
+	}
+	return bytes, nil
+}

codec/optional_packer.go

@@ -7,7 +7,6 @@ import (
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/hypersdk/consts"
-	"github.com/ava-labs/hypersdk/crypto/ed25519"
 )
 
 // OptionalPacker defines a struct that includes a Packer [ip], a bitset
@@ -94,27 +93,6 @@ func (o *OptionalPacker) UnpackID(dest *ids.ID) {
 	}
 }
 
-// PackPublicKey packs [pk] into OptionalPacker if [pk] is not an empty PublicKey.
-// Updates the bitset and offset accordingly.
-func (o *OptionalPacker) PackPublicKey(pk ed25519.PublicKey) {
-	if pk == ed25519.EmptyPublicKey {
-		o.skipBit()
-		return
-	}
-	o.ip.PackPublicKey(pk)
-	o.setBit()
-}
-
-// UnpackPublicKey unpacks a PublicKey into [dest] if the bitset is set at
-// the current offset. Increments offset regardless.
-func (o *OptionalPacker) UnpackPublicKey(dest *ed25519.PublicKey) {
-	if o.checkBit() {
-		o.ip.UnpackPublicKey(true, dest)
-	} else {
-		*dest = ed25519.EmptyPublicKey
-	}
-}
-
 // PackUint64 packs [l] into OptionalPacker if [l] is not an 0.
 // Updates the bitset and offset accordingly.
 func (o *OptionalPacker) PackUint64(l uint64) {

codec/optional_packer_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ava-labs/avalanchego/ids"
 	"github.com/ava-labs/hypersdk/consts"
-	"github.com/ava-labs/hypersdk/crypto/ed25519"
 	"github.com/stretchr/testify/require"
 )
 
@@ -25,56 +24,6 @@ func (o *OptionalPacker) toReader() *OptionalPacker {
 	return pr.NewOptionalReader()
 }
 
-func TestOptionalPackerWriter(t *testing.T) {
-	// Initializes empty writer with a limit two byte limit
-	require := require.New(t)
-	opw := NewOptionalWriter(10_000)
-	require.Empty(opw.ip.Bytes())
-	var pubKey ed25519.PublicKey
-	copy(pubKey[:], TestPublicKey)
-	// Fill OptionalPacker
-	i := 0
-	for i <= consts.MaxUint64Offset {
-		opw.PackPublicKey(pubKey)
-		i += 1
-	}
-	require.Equal(
-		(consts.MaxUint64Offset+1)*ed25519.PublicKeyLen,
-		len(opw.ip.Bytes()),
-		"Bytes not added correctly.",
-	)
-	require.NoError(opw.Err(), "Error packing bytes.")
-	opw.PackPublicKey(pubKey)
-	require.ErrorIs(opw.Err(), ErrTooManyItems, "Error not thrown after over packing.")
-}
-
-func TestOptionalPackerPublicKey(t *testing.T) {
-	require := require.New(t)
-	opw := NewOptionalWriter(10_000)
-	var pubKey ed25519.PublicKey
-	copy(pubKey[:], TestPublicKey)
-	t.Run("Pack", func(t *testing.T) {
-		// Pack empty
-		opw.PackPublicKey(ed25519.EmptyPublicKey)
-		require.Empty(opw.ip.Bytes(), "PackPublickey packed an empty ID.")
-		// Pack ID
-		opw.PackPublicKey(pubKey)
-		require.Equal(TestPublicKey, opw.ip.Bytes(), "PackPublickey did not set bytes correctly.")
-	})
-	t.Run("Unpack", func(t *testing.T) {
-		// Setup optional reader
-		opr := opw.toReader()
-		var unpackedPubkey ed25519.PublicKey
-		// Unpack
-		opr.UnpackPublicKey(&unpackedPubkey)
-		require.Equal(ed25519.EmptyPublicKey[:], unpackedPubkey[:], "PublicKey unpacked correctly")
-		opr.UnpackPublicKey(&unpackedPubkey)
-		require.Equal(pubKey, unpackedPubkey, "PublicKey unpacked correctly")
-		opr.Done()
-		require.NoError(opr.Err())
-	})
-}
-
 func TestOptionalPackerID(t *testing.T) {
 	require := require.New(t)
 	opw := NewOptionalWriter(10_000)

codec/packer.go

@@ -10,13 +10,11 @@ import (
 	"github.com/ava-labs/avalanchego/utils/wrappers"
 
 	"github.com/ava-labs/hypersdk/consts"
-	"github.com/ava-labs/hypersdk/crypto/ed25519"
 	"github.com/ava-labs/hypersdk/window"
 )
 
 // Packer is a wrapper struct for the Packer struct
-// from avalanchego/utils/wrappers/packing.go. It adds methods to
-// pack/unpack ids, PublicKeys and Signatures. A bool [required] parameter is
+// from avalanchego/utils/wrappers/packing.go. A bool [required] parameter is
 // added to many unpacking methods, which signals the packer to add an error
 // if the expected method does not unpack properly.
 type Packer struct {
@@ -73,9 +71,9 @@ func (p *Packer) PackFixedBytes(b []byte) {
 }
 
 func (p *Packer) PackShortBytes(b ShortBytes) {
-	l := len(b)
-	if l > ShortBytesMaxSize {
-		p.addErr(fmt.Errorf("%w: ShortBytes is too large (found=%d)", ErrTooLarge, len(b)))
+	l := b.Len()
+	if !b.Valid() {
+		p.addErr(fmt.Errorf("%w: found=%d", ErrInvalidShortBytes, len(b)))
 		return
 	}
 	p.PackByte(uint8(l))
@@ -134,31 +132,6 @@ func (p *Packer) UnpackInt64(required bool) int64 {
 	return int64(v)
 }
 
-func (p *Packer) PackPublicKey(src ed25519.PublicKey) {
-	p.p.PackFixedBytes(src[:])
-}
-
-// UnpackPublicKey ed25519.PublicKey into [dest].
-func (p *Packer) UnpackPublicKey(required bool, dest *ed25519.PublicKey) {
-	copy((*dest)[:], p.p.UnpackFixedBytes(ed25519.PublicKeyLen))
-	if required && *dest == ed25519.EmptyPublicKey {
-		p.addErr(fmt.Errorf("%w: PublicKey field is not populated", ErrFieldNotPopulated))
-	}
-}
-
-func (p *Packer) PackSignature(src ed25519.Signature) {
-	p.p.PackFixedBytes(src[:])
-}
-
-// UnpackPublicKey ed25519.Signature into [dest].
-// TODO: should add required param?
-func (p *Packer) UnpackSignature(dest *ed25519.Signature) {
-	copy((*dest)[:], p.p.UnpackFixedBytes(ed25519.SignatureLen))
-	if *dest == ed25519.EmptySignature {
-		p.addErr(fmt.Errorf("%w: Signature field is not populated", ErrFieldNotPopulated))
-	}
-}
-
 func (p *Packer) PackInt(v int) {
 	p.p.PackInt(uint32(v))
 }