txnbuild: Reenable Multiplexed strkeys (SEP23 M-addresses) behind flags

clients/horizonclient/client.go

@@ -14,6 +14,7 @@ import (
 	"time"
 
 	"github.com/stellar/go/txnbuild"
+	"github.com/stellar/go/xdr"
 
 	"github.com/manucorporat/sse"
 
@@ -47,7 +48,7 @@ func (c *Client) checkMemoRequired(transaction *txnbuild.Transaction) error {
 	for i, op := range transaction.Operations() {
 		var destination string
 
-		if err := op.Validate(); err != nil {
+		if err := op.Validate(true); err != nil {
 			return err
 		}
 
@@ -64,10 +65,15 @@ func (c *Client) checkMemoRequired(transaction *txnbuild.Transaction) error {
 			continue
 		}
 
-		// TODO: once we support M-strkeys (SEP23), also check whether the destination
-		//       is a muxed account with a memo ID.
+		muxed, err := xdr.AddressToMuxedAccount(destination)
+		if err != nil {
+			return errors.Wrapf(err, "destination %v is not a valid address", destination)
+		}
+		// Skip destination addresses with a memo id because the address has a memo
+		// encoded within it
+		destinationHasMemoID := muxed.Type == xdr.CryptoKeyTypeKeyTypeMuxedEd25519
 
-		if destinations[destination] {
+		if destinations[destination] || destinationHasMemoID {
 			continue
 		}
 		destinations[destination] = true

clients/horizonclient/main_test.go

@@ -17,6 +17,8 @@ import (
 	"github.com/stellar/go/support/errors"
 	"github.com/stellar/go/support/http/httptest"
 	"github.com/stellar/go/txnbuild"
+	"github.com/stellar/go/xdr"
+
 	"github.com/stretchr/testify/assert"
 )
 
@@ -903,6 +905,70 @@ func TestSubmitTransactionRequest(t *testing.T) {
 	assert.Equal(t, ErrAccountRequiresMemo, errors.Cause(err))
 }
 
+func TestSubmitTransactionRequestMuxedAccounts(t *testing.T) {
+	hmock := httptest.NewClient()
+	client := &Client{
+		HorizonURL: "https://localhost/",
+		HTTP:       hmock,
+	}
+
+	kp := keypair.MustParseFull("SA26PHIKZM6CXDGR472SSGUQQRYXM6S437ZNHZGRM6QA4FOPLLLFRGDX")
+	accountID := xdr.MustAddress(kp.Address())
+	mx := xdr.MuxedAccount{
+		Type: xdr.CryptoKeyTypeKeyTypeMuxedEd25519,
+		Med25519: &xdr.MuxedAccountMed25519{
+			Id:      0xcafebabe,
+			Ed25519: *accountID.Ed25519,
+		},
+	}
+	sourceAccount := txnbuild.NewSimpleAccount(mx.Address(), int64(0))
+
+	payment := txnbuild.Payment{
+		Destination: kp.Address(),
+		Amount:      "10",
+		Asset:       txnbuild.NativeAsset{},
+	}
+
+	tx, err := txnbuild.NewTransaction(
+		txnbuild.TransactionParams{
+			SourceAccount:        &sourceAccount,
+			IncrementSequenceNum: true,
+			Operations:           []txnbuild.Operation{&payment},
+			BaseFee:              txnbuild.MinBaseFee,
+			Timebounds:           txnbuild.NewTimebounds(0, 10),
+			EnableMuxedAccounts:  true,
+		},
+	)
+	assert.NoError(t, err)
+
+	tx, err = tx.Sign(network.TestNetworkPassphrase, kp)
+	assert.NoError(t, err)
+
+	// successful tx with config.memo_required not found
+	hmock.On(
+		"POST",
+		"https://localhost/transactions?tx=AAAAAgAAAQAAAAAAyv66vgU08yUQ8sHqhY8j9mXWwERfHC%2F3cKFSe%2FspAr0rGtO2AAAAZAAAAAAAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAoAAAAAAAAAAQAAAAAAAAABAAAAAAU08yUQ8sHqhY8j9mXWwERfHC%2F3cKFSe%2FspAr0rGtO2AAAAAAAAAAAF9eEAAAAAAAAAAAErGtO2AAAAQJvQkE9UVo%2FmfFBl%2F8ZPTzSUyVO4nvW0BYfnbowoBPEdRfLOLQz28v6sBKQc2b86NUfVHN5TQVo3%2BjH4nK9wVgk%3D",
+	).ReturnString(200, txSuccess)
+
+	hmock.On(
+		"GET",
+		"https://localhost/accounts/GACTJ4ZFCDZMD2UFR4R7MZOWYBCF6HBP65YKCUT37MUQFPJLDLJ3N5D2/data/config.memo_required",
+	).ReturnString(404, notFoundResponse)
+
+	_, err = client.SubmitTransaction(tx)
+	assert.NoError(t, err)
+
+	// memo required - does not submit transaction
+	hmock.On(
+		"GET",
+		"https://localhost/accounts/GACTJ4ZFCDZMD2UFR4R7MZOWYBCF6HBP65YKCUT37MUQFPJLDLJ3N5D2/data/config.memo_required",
+	).ReturnJSON(200, memoRequiredResponse)
+
+	_, err = client.SubmitTransaction(tx)
+	assert.Error(t, err)
+	assert.Equal(t, ErrAccountRequiresMemo, errors.Cause(err))
+}
+
 func TestSubmitFeeBumpTransaction(t *testing.T) {
 	hmock := httptest.NewClient()
 	client := &Client{

strkey/decode_test.go

@@ -24,6 +24,18 @@ func TestDecode(t *testing.T) {
 				0xec, 0x9c, 0x07, 0x3d, 0x05, 0xc7, 0xb1, 0x03,
 			},
 		},
+		{
+			Name:                "MuxedAccount",
+			Address:             "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLK",
+			ExpectedVersionByte: VersionByteMuxedAccount,
+			ExpectedPayload: []byte{
+				0x3f, 0x0c, 0x34, 0xbf, 0x93, 0xad, 0x0d, 0x99,
+				0x71, 0xd0, 0x4c, 0xcc, 0x90, 0xf7, 0x05, 0x51,
+				0x1c, 0x83, 0x8a, 0xad, 0x97, 0x34, 0xa4, 0xa2,
+				0xfb, 0x0d, 0x7a, 0x03, 0xfc, 0x7f, 0xe8, 0x9a,
+				0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+		},
 		{
 			Name:                "Seed",
 			Address:             "SBU2RRGLXH3E5CQHTD3ODLDF2BWDCYUSSBLLZ5GNW7JXHDIYKXZWHOKR",
@@ -85,6 +97,83 @@ func TestDecode(t *testing.T) {
 	// corrupted payload
 	_, err = Decode(VersionByteAccountID, "GA3D5KRYM6CB7OWOOOORR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQHES5")
 	assert.Error(t, err)
+
+	// non-canonical representation due to extra character
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLKA")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused leftover character")
+	}
+
+	// non-canonical representation due to leftover bits set to 1 (some of the test strkeys are too short for a muxed account
+	// but they comply with the test's purpose all the same)
+
+	// 1 unused bit (length 69)
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLH")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAACJUR")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// 4 unused bits (length 68)
+
+	// 'B' is equivalent to 0b00001
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJB")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// 'C' is equivalent to 0b00010
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJC")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// 'E' is equivalent to 0b00100
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJE")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// 'I' is equivalent to 0b01000
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJI")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// '7' is equivalent to 0b11111
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJ7")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// '6' is equivalent to 0b11110
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJ6")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// '4' is equivalent to 0b11100
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJ4")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+	// 'Y' is equivalent to 0b11000
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJY")
+	if assert.Error(t, err) {
+		assert.Contains(t, err.Error(), "unused bits should be set to 0")
+	}
+
+	// 'Q' is equivalent to 0b10000, so there should be no error
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJQ")
+	assert.NotContains(t, err.Error(), "unused bits should be set to 0")
+
+	// Padding bytes are not allowed
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLK===")
+	assert.Contains(t, err.Error(), "illegal base32 data")
+
+	// Invalid algorithm (low 3 bits of version byte are 7)
+	_, err = Decode(VersionByteMuxedAccount, "M47QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAACJUQ")
+	assert.Contains(t, err.Error(), "invalid version byte")
+
+	// Invalid checksum
+	_, err = Decode(VersionByteMuxedAccount, "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAACJUO")
+	assert.Contains(t, err.Error(), "invalid checksum")
 }
 
 func TestMalformed(t *testing.T) {

strkey/encode_test.go

@@ -24,6 +24,18 @@ func TestEncode(t *testing.T) {
 			},
 			Expected: "GA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQHES5",
 		},
+		{
+			Name:        "MuxedAccount",
+			VersionByte: VersionByteMuxedAccount,
+			Payload: []byte{
+				0x3f, 0x0c, 0x34, 0xbf, 0x93, 0xad, 0x0d, 0x99,
+				0x71, 0xd0, 0x4c, 0xcc, 0x90, 0xf7, 0x05, 0x51,
+				0x1c, 0x83, 0x8a, 0xad, 0x97, 0x34, 0xa4, 0xa2,
+				0xfb, 0x0d, 0x7a, 0x03, 0xfc, 0x7f, 0xe8, 0x9a,
+				0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			},
+			Expected: "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLK",
+		},
 		{
 			Name:        "Seed",
 			VersionByte: VersionByteSeed,

strkey/main.go

@@ -24,6 +24,9 @@ const (
 	//VersionByteSeed is the version byte used for encoded stellar seed
 	VersionByteSeed = 18 << 3 // Base32-encodes to 'S...'
 
+	//VersionByteMuxedAccounts is the version byte used for encoded stellar multiplexed addresses
+	VersionByteMuxedAccount = 12 << 3 // Base32-encodes to 'M...'
+
 	//VersionByteHashTx is the version byte used for encoded stellar hashTx
 	//signer keys.
 	VersionByteHashTx = 19 << 3 // Base32-encodes to 'T...'
@@ -161,9 +164,7 @@ func Version(src string) (VersionByte, error) {
 // is not one of the defined valid version byte constants.
 func checkValidVersionByte(version VersionByte) error {
 	switch version {
-	// intentionally disallow M-strkeys  (versionByteMuxedAccount)
-	// until SEP23 leaves the Draft status.
-	case VersionByteAccountID, VersionByteSeed, VersionByteHashTx, VersionByteHashX:
+	case VersionByteAccountID, VersionByteMuxedAccount, VersionByteSeed, VersionByteHashTx, VersionByteHashX:
 		return nil
 	default:
 		return ErrInvalidVersionByte

txnbuild/CHANGELOG.md

@@ -8,11 +8,16 @@ file.  This project adheres to [Semantic Versioning](http://semver.org/).
 ### Breaking changes
 
 * `AllowTrustOpAsset` was renamed to `AssetCode`, `{Must}NewAllowTrustAsset` was renamed to `{Must}NewAssetCodeFromString`.
+* Some methods from the `Operation` interface (`BuildXDR()`,`FromXDR()` and `Validate()`) now take an additional `bool` parameter (`withMuxedAccounts`)
+  to indicate whether [SEP23](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md) M-strkeys should be enabled.
 
 ### New features
 
-Add support for Stellar Protocol 16 (CAP35): `Clawback` operations.
-
+* Add support for Stellar Protocol 16 (CAP35): `Clawback`, `ClawbackClaimableBalance` and `SetTrustlineFlags` operations.
+* Add opt-in support for [SEP23](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md) M-strkeys for `MuxedAccount`s:
+  * Some methods from the `Operation` interface (`BuildXDR()`,`FromXDR()` and `Validate()`) now take an additional `bool` parameter (`withMuxedAccounts`)
+  * The parameters from `NewFeeBumpTransaction()` and `NewTransaction()` now include a new field (`EnableMuxedAccounts`) to enable M-strekeys.
+  * `TransactionFromXDR()` now allows passing a `TransactionFromXDROptionEnableMuxedAccounts` option, to enable M-strkey parsing.
 ## [v6.0.0](https://github.com/stellar/go/releases/tag/horizonclient-v6.0.0) - 2021-02-22
 
 ### Breaking changes

txnbuild/account_merge.go

@@ -13,10 +13,14 @@ type AccountMerge struct {
 }
 
 // BuildXDR for AccountMerge returns a fully configured XDR Operation.
-func (am *AccountMerge) BuildXDR() (xdr.Operation, error) {
+func (am *AccountMerge) BuildXDR(withMuxedAccounts bool) (xdr.Operation, error) {
 	var xdrOp xdr.MuxedAccount
-
-	err := xdrOp.SetAddress(am.Destination)
+	var err error
+	if withMuxedAccounts {
+		err = xdrOp.SetAddress(am.Destination)
+	} else {
+		err = xdrOp.SetEd25519Address(am.Destination)
+	}
 	if err != nil {
 		return xdr.Operation{}, errors.Wrap(err, "failed to set destination address")
 	}
@@ -27,29 +31,42 @@ func (am *AccountMerge) BuildXDR() (xdr.Operation, error) {
 		return xdr.Operation{}, errors.Wrap(err, "failed to build XDR OperationBody")
 	}
 	op := xdr.Operation{Body: body}
-	SetOpSourceAccount(&op, am.SourceAccount)
+	if withMuxedAccounts {
+		SetOpSourceMuxedAccount(&op, am.SourceAccount)
+	} else {
+		SetOpSourceAccount(&op, am.SourceAccount)
+	}
 	return op, nil
 }
 
 // FromXDR for AccountMerge initialises the txnbuild struct from the corresponding xdr Operation.
-func (am *AccountMerge) FromXDR(xdrOp xdr.Operation) error {
+func (am *AccountMerge) FromXDR(xdrOp xdr.Operation, withMuxedAccounts bool) error {
 	if xdrOp.Body.Type != xdr.OperationTypeAccountMerge {
 		return errors.New("error parsing account_merge operation from xdr")
 	}
 
-	am.SourceAccount = accountFromXDR(xdrOp.SourceAccount)
+	am.SourceAccount = accountFromXDR(xdrOp.SourceAccount, withMuxedAccounts)
 	if xdrOp.Body.Destination != nil {
-		aid := xdrOp.Body.Destination.ToAccountId()
-		am.Destination = aid.Address()
+		if withMuxedAccounts {
+			am.Destination = xdrOp.Body.Destination.Address()
+		} else {
+			aid := xdrOp.Body.Destination.ToAccountId()
+			am.Destination = aid.Address()
+		}
 	}
 
 	return nil
 }
 
 // Validate for AccountMerge validates the required struct fields. It returns an error if any of the fields are
 // invalid. Otherwise, it returns nil.
-func (am *AccountMerge) Validate() error {
-	_, err := xdr.AddressToAccountId(am.Destination)
+func (am *AccountMerge) Validate(withMuxedAccounts bool) error {
+	var err error
+	if withMuxedAccounts {
+		_, err = xdr.AddressToAccountId(am.Destination)
+	} else {
+		_, err = xdr.AddressToMuxedAccount(am.Destination)
+	}
 	if err != nil {
 		return NewValidationError("Destination", err.Error())
 	}

txnbuild/account_merge_test.go

@@ -23,7 +23,21 @@ func TestAccountMergeValidate(t *testing.T) {
 		},
 	)
 	if assert.Error(t, err) {
-		expected := "strkey is 4 bytes long; minimum valid length is 5"
+		expected := "invalid address"
 		assert.Contains(t, err.Error(), expected)
 	}
 }
+
+func TestAccountMergeRoundtrip(t *testing.T) {
+	accountMerge := AccountMerge{
+		SourceAccount: "GB7BDSZU2Y27LYNLALKKALB52WS2IZWYBDGY6EQBLEED3TJOCVMZRH7H",
+		Destination:   "GB7BDSZU2Y27LYNLALKKALB52WS2IZWYBDGY6EQBLEED3TJOCVMZRH7H",
+	}
+	testOperationsMarshallingRoundtrip(t, []Operation{&accountMerge}, false)
+
+	accountMerge = AccountMerge{
+		SourceAccount: "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVAAAAAAAAAAAAAJLK",
+		Destination:   "GB7BDSZU2Y27LYNLALKKALB52WS2IZWYBDGY6EQBLEED3TJOCVMZRH7H",
+	}
+	testOperationsMarshallingRoundtrip(t, []Operation{&accountMerge}, true)
+}