Merge pull request #5689 from tamirms/protocol-23

Merge master into protocol-23 branch

Author: tamirms

.github/workflows/horizon.yml

@@ -10,7 +10,7 @@ jobs:
     name: Integration tests
     strategy:
       matrix:
-        os: [ubuntu-20.04, ubuntu-22.04]
+        os: [ubuntu-22.04]
         go: ["1.22", "1.23"]
         pg: [12, 16]
         protocol-version: [22]

amount/main.go

@@ -82,6 +82,15 @@ func ParseInt64(v string) (int64, error) {
 	return i, nil
 }
 
+// MustParseInt64Raw simply converts an string into a 64-bit signed integer
+func MustParseInt64Raw(v string) int64 {
+	i, err := strconv.ParseInt(v, 10, 64)
+	if err != nil {
+		panic(err)
+	}
+	return i
+}
+
 // IntStringToAmount converts string integer value and converts it to stellar
 // "amount". In other words, it divides the given string integer value by 10^7
 // and returns the string representation of that number.
@@ -139,3 +148,17 @@ func StringFromInt64(v int64) string {
 	r.Quo(r, bigOne)
 	return r.FloatString(7)
 }
+
+// No conversion. Simply convert int64 to string. Useful to have this in one place, should the underlying implementation change
+func String64Raw(v xdr.Int64) string {
+	return strconv.FormatInt(int64(v), 10)
+}
+
+func String128Raw(v xdr.Int128Parts) string {
+	// the upper half of the i128 always indicates its sign regardless of its
+	// value, just like a native signed type
+	val := big.NewInt(int64(v.Hi))
+	val.Lsh(val, 64).Add(val, new(big.Int).SetUint64(uint64(v.Lo)))
+
+	return val.String()
+}

go.mod

@@ -135,7 +135,7 @@ require (
 	github.com/gavv/monotime v0.0.0-20161010190848-47d58efa6955 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/protobuf v1.5.4 // indirect
-	github.com/google/go-cmp v0.6.0 // indirect
+	github.com/google/go-cmp v0.7.0
 	github.com/google/go-querystring v0.0.0-20160401233042-9235644dd9e5 // indirect
 	github.com/googleapis/gax-go/v2 v2.12.4 // indirect
 	github.com/hashicorp/golang-lru v1.0.2

go.sum

@@ -237,8 +237,8 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
 github.com/google/go-querystring v0.0.0-20160401233042-9235644dd9e5 h1:oERTZ1buOUYlpmKaqlO5fYmz8cZ1rYu5DieJzF4ZVmU=
 github.com/google/go-querystring v0.0.0-20160401233042-9235644dd9e5/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
 github.com/google/gopacket v1.1.20-0.20210429153827-3eaba0894325/go.mod h1:riddUzxTSBpJXk3qBHtYr4qOhFhT6k/1c0E3qkQjQpA=

ingest/address/address.pb.go

@@ -1,18 +1,63 @@
 package asset
 
+import (
+	"github.com/stellar/go/xdr"
+	"strings"
+)
+
 // NewNativeAsset creates an Asset representing the native token (XLM).
 func NewNativeAsset() *Asset {
 	return &Asset{AssetType: &Asset_Native{Native: true}}
 }
 
-// NewIssuedAsset creates an Asset with an asset code and issuer.
-func NewIssuedAsset(assetCode, issuer string) *Asset {
+func NewProtoAsset(asset xdr.Asset) *Asset {
+	if asset.IsNative() {
+		return NewNativeAsset()
+	}
 	return &Asset{
 		AssetType: &Asset_IssuedAsset{
 			IssuedAsset: &IssuedAsset{
-				AssetCode: assetCode,
-				Issuer:    issuer,
+				// Need to trim the extra null characters from showing in the code when saving to assetCode
+				AssetCode: strings.TrimRight(asset.GetCode(), "\x00"),
+				Issuer:    asset.GetIssuer(),
 			},
 		},
 	}
 }
+
+func (a *Asset) ToXdrAsset() xdr.Asset {
+	if a == nil {
+		panic("nil asset")
+	}
+	switch a := a.AssetType.(type) {
+	case *Asset_Native:
+		return xdr.MustNewNativeAsset()
+	case *Asset_IssuedAsset:
+		return xdr.MustNewCreditAsset(a.IssuedAsset.AssetCode, a.IssuedAsset.Issuer)
+	}
+	panic("unknown asset type")
+}
+
+func (a *Asset) Equals(other *Asset) bool {
+	// If both assets are the same type (native or issued asset)
+	if a.AssetType == nil || other.AssetType == nil {
+		return false
+	}
+
+	switch a := a.AssetType.(type) {
+	case *Asset_Native:
+		if b, ok := other.AssetType.(*Asset_Native); ok {
+			// Both assets are native; compare the native boolean value.
+			// Ideally i could simply be returning true here, but it is more idiomatic to check for the flag equality
+			return a.Native == b.Native
+		}
+	case *Asset_IssuedAsset:
+		if b, ok := other.AssetType.(*Asset_IssuedAsset); ok {
+			// Both assets are issued assets; compare their asset_code and issuer
+			return a.IssuedAsset.AssetCode == b.IssuedAsset.AssetCode &&
+				a.IssuedAsset.Issuer == b.IssuedAsset.Issuer
+		}
+	}
+
+	return false
+}

ingest/asset/asset.go

@@ -1,11 +1,18 @@
 package asset
 
 import (
+	"github.com/stellar/go/xdr"
 	"github.com/stretchr/testify/assert"
 	"google.golang.org/protobuf/proto"
 	"testing"
 )
 
+var (
+	assetCode = "USDC"
+	issuer    = "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"
+	usdcAsset = xdr.MustNewCreditAsset(assetCode, issuer)
+)
+
 func TestNewNativeAsset(t *testing.T) {
 	nativeAsset := NewNativeAsset()
 
@@ -15,25 +22,26 @@ func TestNewNativeAsset(t *testing.T) {
 	assert.True(t, nativeAsset.GetNative(), "Native asset should have Native set to true")
 }
 
-func TestNewIssuedAsset(t *testing.T) {
-	assetCode := "USDC"
-	issuer := "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"
-
-	issuedAsset := NewIssuedAsset(assetCode, issuer)
+func TestNewProtoAsset(t *testing.T) {
 
-	assert.NotNil(t, issuedAsset, "Issued asset should not be nil")
-	assert.IsType(t, &Asset{}, issuedAsset, "Issued asset should be of type *Asset")
-	assert.IsType(t, &Asset_IssuedAsset{}, issuedAsset.AssetType, "AssetType should be *Asset_IssuedAsset")
+	usdcProtoAsset := NewProtoAsset(usdcAsset)
 
+	assert.NotNil(t, usdcProtoAsset, "asset should not be nil")
+	assert.IsType(t, &Asset{}, usdcProtoAsset, "asset should be of type *Asset")
+	assert.IsType(t, &Asset_IssuedAsset{}, usdcProtoAsset.AssetType, "AssetType should be *Asset_IssuedAsset")
 	// Check issued asset fields
-	assert.Equal(t, assetCode, issuedAsset.GetIssuedAsset().AssetCode, "Asset code should match")
-	assert.Equal(t, issuer, issuedAsset.GetIssuedAsset().Issuer, "Issuer should match")
+	assert.Equal(t, assetCode, usdcProtoAsset.GetIssuedAsset().AssetCode, "Asset code should match")
+	assert.Equal(t, issuer, usdcProtoAsset.GetIssuedAsset().Issuer, "Issuer should match")
+
+	xlmProtoAsset := NewProtoAsset(xdr.MustNewNativeAsset())
+	assert.NotNil(t, xlmProtoAsset, "asset should not be nil")
+	assert.IsType(t, &Asset{}, xlmProtoAsset, "asset should be of type *Asset")
+	assert.IsType(t, &Asset_Native{}, xlmProtoAsset.AssetType, "AssetType should be *Asset_Native")
+	assert.True(t, xlmProtoAsset.GetNative(), "Native asset should have Native set to true")
 }
 
 func TestAssetSerialization(t *testing.T) {
-	assetCode := "USDC"
-	issuer := "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN"
-	original := NewIssuedAsset(assetCode, issuer)
+	original := NewProtoAsset(usdcAsset)
 
 	serializedAsset, err := proto.Marshal(original)
 	assert.NoError(t, err, "Failed to marshal asset")