Allow address to be formatted separately to bytes

Signed-off-by: Peter Broadhurst <peter.broadhurst@kaleido.io>

Author: peterbroadhurst

pkg/abi/outputserialization.go

@@ -27,6 +27,7 @@ import (
 
 	"github.com/hyperledger/firefly-common/pkg/i18n"
 	"github.com/hyperledger/firefly-signer/internal/signermsgs"
+	"github.com/hyperledger/firefly-signer/pkg/ethtypes"
 )
 
 // Serializer contains a set of options for how to serialize an parsed
@@ -37,6 +38,7 @@ type Serializer struct {
 	fs     FloatSerializer
 	bs     ByteSerializer
 	dn     DefaultNameGenerator
+	ad     AddressSerializer
 	pretty bool
 }
 
@@ -52,6 +54,7 @@ func NewSerializer() *Serializer {
 		fs: Base10StringFloatSerializer,
 		bs: HexByteSerializer,
 		dn: NumericDefaultNameGenerator,
+		ad: nil, // we fall back to bytes serializer to preserve compatibility
 	}
 }
 
@@ -82,6 +85,8 @@ type FloatSerializer func(f *big.Float) interface{}
 
 type ByteSerializer func(b []byte) interface{}
 
+type AddressSerializer func(addr [20]byte) interface{}
+
 func (s *Serializer) SetFormattingMode(ts FormattingMode) *Serializer {
 	s.ts = ts
 	return s
@@ -102,6 +107,11 @@ func (s *Serializer) SetByteSerializer(bs ByteSerializer) *Serializer {
 	return s
 }
 
+func (s *Serializer) SetAddressSerializer(ad AddressSerializer) *Serializer {
+	s.ad = ad
+	return s
+}
+
 func (s *Serializer) SetDefaultNameGenerator(dn DefaultNameGenerator) *Serializer {
 	s.dn = dn
 	return s
@@ -158,6 +168,18 @@ func HexByteSerializer0xPrefix(b []byte) interface{} {
 	return "0x" + hex.EncodeToString(b)
 }
 
+func HexAddrSerializer0xPrefix(addr [20]byte) interface{} {
+	return ethtypes.Address0xHex(addr).String()
+}
+
+func HexAddrSerializerPlain(addr [20]byte) interface{} {
+	return ethtypes.AddressPlainHex(addr).String()
+}
+
+func ChecksumAddrSerializer(addr [20]byte) interface{} {
+	return ethtypes.AddressWithChecksum(addr).String()
+}
+
 func Base64ByteSerializer(b []byte) interface{} {
 	return base64.StdEncoding.EncodeToString(b)
 }
@@ -210,9 +232,12 @@ func (s *Serializer) serializeElementaryType(ctx context.Context, breadcrumbs st
 	case ElementaryTypeInt, ElementaryTypeUint:
 		return s.is(cv.Value.(*big.Int)), nil
 	case ElementaryTypeAddress:
-		addr := make([]byte, 20)
-		cv.Value.(*big.Int).FillBytes(addr)
-		return s.bs(addr), nil
+		var addr [20]byte
+		cv.Value.(*big.Int).FillBytes(addr[:])
+		if s.ad == nil {
+			return s.bs(addr[:]), nil
+		}
+		return s.ad(addr), nil
 	case ElementaryTypeBool:
 		return (cv.Value.(*big.Int).Int64() == 1), nil
 	case ElementaryTypeFixed, ElementaryTypeUfixed:

pkg/abi/outputserialization_test.go

@@ -112,9 +112,6 @@ func TestJSONSerializationFormatsTuple(t *testing.T) {
 
 func TestJSONSerializationNumbers(t *testing.T) {
 
-	abi := testABI(t, sampleABI1)
-	assert.NotNil(t, abi)
-
 	v, err := (ParameterArray{{Type: "uint"}, {Type: "int"}}).ParseJSON([]byte(`[
 	   "123000000000000000000000112233",
 	   "-0x18d6f3720c92d9d437801b669"
@@ -144,6 +141,56 @@ func TestJSONSerializationNumbers(t *testing.T) {
 
 }
 
+func TestJSONSerializationAddresses(t *testing.T) {
+
+	v, err := (ParameterArray{{Type: "address"}}).ParseJSON([]byte(`[
+	   "0xC66A547171fdE5FbEfC546B58E66AaC300Cb6150"
+	]`))
+	assert.NoError(t, err)
+
+	j, err := v.JSON()
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{
+	   "0": "c66a547171fde5fbefc546b58e66aac300cb6150"
+	}`, string(j))
+
+	j, err = NewSerializer().
+		SetByteSerializer(Base64ByteSerializer). // confirming no effect
+		SerializeJSON(v)
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{
+		"0": "xmpUcXH95fvvxUa1jmaqwwDLYVA="
+	}`, string(j))
+
+	j, err = NewSerializer().
+		SetByteSerializer(Base64ByteSerializer). // confirming no effect
+		SetAddressSerializer(HexAddrSerializer0xPrefix).
+		SerializeJSON(v)
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{
+		"0": "0xc66a547171fde5fbefc546b58e66aac300cb6150"
+	 }`, string(j))
+
+	j, err = NewSerializer().
+		SetByteSerializer(Base64ByteSerializer). // confirming no effect
+		SetAddressSerializer(HexAddrSerializerPlain).
+		SerializeJSON(v)
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{
+		"0": "c66a547171fde5fbefc546b58e66aac300cb6150"
+	}`, string(j))
+
+	j, err = NewSerializer().
+		SetByteSerializer(Base64ByteSerializer). // confirming no effect
+		SetAddressSerializer(ChecksumAddrSerializer).
+		SerializeJSON(v)
+	assert.NoError(t, err)
+	assert.JSONEq(t, `{
+		"0": "0xC66A547171fdE5FbEfC546B58E66AaC300Cb6150"
+	}`, string(j))
+
+}
+
 func TestJSONSerializationForTypes(t *testing.T) {
 
 	abi := testABI(t, sampleABI2)