diff --git a/Gemfile.lock b/Gemfile.lock
index 99460149ec..723d0fb05a 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -1,6 +1,6 @@
 GIT
   remote: https://github.com/stellar/xdrgen.git
-  revision: b960ce7a979bc64d11f7512962733ee88ea87a2b
+  revision: 7d53fb17bcb6155d916db09e48c880aae42f624d
   ref: master
   specs:
     xdrgen (0.1.1)
diff --git a/benchmarks/xdr_test.go b/benchmarks/xdr_test.go
index 372ca9d790..60d60b0c11 100644
--- a/benchmarks/xdr_test.go
+++ b/benchmarks/xdr_test.go
@@ -43,7 +43,7 @@ func BenchmarkXDRUnmarshalWithReflection(b *testing.B) {
 	)
 	for i := 0; i < b.N; i++ {
 		r.Reset(input)
-		_, _ = xdr.Unmarshal(&r, &te)
+		_, _ = xdr3.Unmarshal(&r, &te)
 	}
 }
 
diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go
index 0aa5040732..3edb8e47e5 100644
--- a/txnbuild/transaction_test.go
+++ b/txnbuild/transaction_test.go
@@ -1879,7 +1879,7 @@ func TestReadChallengeTx_invalidCorrupted(t *testing.T) {
 		t,
 		err,
 		"could not parse challenge: unable to unmarshal transaction envelope: "+
-			"xdr:decode: switch '68174086' is not valid enum value for union",
+			"decoding EnvelopeType: '68174086' is not a valid EnvelopeType enum value",
 	)
 }
 
diff --git a/xdr/xdr_generated.go b/xdr/xdr_generated.go
index 4c2245a45d..491dff3330 100644
--- a/xdr/xdr_generated.go
+++ b/xdr/xdr_generated.go
@@ -25,8 +25,16 @@ type xdrType interface {
 	xdrType()
 }
 
+type decoderFrom interface {
+	DecodeFrom(d *xdr.Decoder) (int, error)
+}
+
 // Unmarshal reads an xdr element from `r` into `v`.
 func Unmarshal(r io.Reader, v interface{}) (int, error) {
+	if decodable, ok := v.(decoderFrom); ok {
+		d := xdr.NewDecoder(r)
+		return decodable.DecodeFrom(d)
+	}
 	// delegate to xdr package's Unmarshal
 	return xdr.Unmarshal(r, v)
 }
@@ -61,6 +69,20 @@ func (s Value) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Value)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Value) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	(*s), nTmp, err = d.DecodeOpaque(0)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Value: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Value) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -71,7 +93,9 @@ func (s Value) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Value) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -111,6 +135,25 @@ func (s *ScpBallot) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpBallot)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpBallot) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Counter.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Value.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Value: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpBallot) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -121,7 +164,9 @@ func (s ScpBallot) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpBallot) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -184,6 +229,21 @@ func (e ScpStatementType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ScpStatementType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ScpStatementType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpStatementType: %s", err)
+	}
+	if _, ok := scpStatementTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ScpStatementType enum value", v)
+	}
+	*e = ScpStatementType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatementType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -194,7 +254,9 @@ func (s ScpStatementType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatementType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -249,6 +311,53 @@ func (s *ScpNomination) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpNomination)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpNomination) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.QuorumSetHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Value: %s", err)
+	}
+	s.Votes = nil
+	if l > 0 {
+		s.Votes = make([]Value, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Votes[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Value: %s", err)
+			}
+		}
+	}
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Value: %s", err)
+	}
+	s.Accepted = nil
+	if l > 0 {
+		s.Accepted = make([]Value, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Accepted[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Value: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpNomination) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -259,7 +368,9 @@ func (s ScpNomination) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpNomination) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -329,6 +440,64 @@ func (s *ScpStatementPrepare) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpStatementPrepare)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpStatementPrepare) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.QuorumSetHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.Ballot.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpBallot: %s", err)
+	}
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpBallot: %s", err)
+	}
+	s.Prepared = nil
+	if b {
+		s.Prepared = new(ScpBallot)
+		nTmp, err = s.Prepared.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpBallot: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpBallot: %s", err)
+	}
+	s.PreparedPrime = nil
+	if b {
+		s.PreparedPrime = new(ScpBallot)
+		nTmp, err = s.PreparedPrime.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpBallot: %s", err)
+		}
+	}
+	nTmp, err = s.NC.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NH.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatementPrepare) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -339,7 +508,9 @@ func (s ScpStatementPrepare) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatementPrepare) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -394,6 +565,40 @@ func (s *ScpStatementConfirm) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpStatementConfirm)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpStatementConfirm) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Ballot.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpBallot: %s", err)
+	}
+	nTmp, err = s.NPrepared.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NCommit.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NH.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.QuorumSetHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatementConfirm) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -404,7 +609,9 @@ func (s ScpStatementConfirm) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatementConfirm) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -449,6 +656,30 @@ func (s *ScpStatementExternalize) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpStatementExternalize)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpStatementExternalize) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Commit.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpBallot: %s", err)
+	}
+	nTmp, err = s.NH.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.CommitQuorumSetHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatementExternalize) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -459,7 +690,9 @@ func (s ScpStatementExternalize) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatementExternalize) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -705,6 +938,54 @@ func (u ScpStatementPledges) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (ScpStatementType) switch value '%d' is not valid for union ScpStatementPledges", u.Type)
 }
 
+var _ decoderFrom = (*ScpStatementPledges)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ScpStatementPledges) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpStatementType: %s", err)
+	}
+	switch ScpStatementType(u.Type) {
+	case ScpStatementTypeScpStPrepare:
+		u.Prepare = new(ScpStatementPrepare)
+		nTmp, err = (*u.Prepare).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpStatementPrepare: %s", err)
+		}
+		return n, nil
+	case ScpStatementTypeScpStConfirm:
+		u.Confirm = new(ScpStatementConfirm)
+		nTmp, err = (*u.Confirm).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpStatementConfirm: %s", err)
+		}
+		return n, nil
+	case ScpStatementTypeScpStExternalize:
+		u.Externalize = new(ScpStatementExternalize)
+		nTmp, err = (*u.Externalize).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpStatementExternalize: %s", err)
+		}
+		return n, nil
+	case ScpStatementTypeScpStNominate:
+		u.Nominate = new(ScpNomination)
+		nTmp, err = (*u.Nominate).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpNomination: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ScpStatementPledges has invalid Type (ScpStatementType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatementPledges) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -715,7 +996,9 @@ func (s ScpStatementPledges) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatementPledges) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -792,6 +1075,30 @@ func (s *ScpStatement) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpStatement)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpStatement) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.NodeId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.SlotIndex.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.Pledges.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpStatementPledges: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpStatement) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -802,7 +1109,9 @@ func (s ScpStatement) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpStatement) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -842,6 +1151,25 @@ func (s *ScpEnvelope) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpEnvelope)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpEnvelope) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Statement.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpStatement: %s", err)
+	}
+	nTmp, err = s.Signature.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpEnvelope) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -852,7 +1180,9 @@ func (s ScpEnvelope) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpEnvelope) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -907,6 +1237,53 @@ func (s *ScpQuorumSet) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpQuorumSet)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpQuorumSet) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Threshold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	s.Validators = nil
+	if l > 0 {
+		s.Validators = make([]NodeId, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Validators[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding NodeId: %s", err)
+			}
+		}
+	}
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpQuorumSet: %s", err)
+	}
+	s.InnerSets = nil
+	if l > 0 {
+		s.InnerSets = make([]ScpQuorumSet, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.InnerSets[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ScpQuorumSet: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpQuorumSet) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -917,7 +1294,9 @@ func (s ScpQuorumSet) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpQuorumSet) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -978,6 +1357,20 @@ func (s AccountId) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AccountId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AccountId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = (*PublicKey)(s).DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PublicKey: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -988,7 +1381,9 @@ func (s AccountId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1023,6 +1418,20 @@ func (s *Thresholds) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Thresholds)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Thresholds) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Thresholds: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Thresholds) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1033,7 +1442,9 @@ func (s Thresholds) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Thresholds) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1068,6 +1479,22 @@ func (s String32) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*String32)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *String32) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v string
+	v, nTmp, err = d.DecodeString(32)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String32: %s", err)
+	}
+	*s = String32(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s String32) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1078,7 +1505,9 @@ func (s String32) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *String32) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1113,6 +1542,22 @@ func (s String64) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*String64)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *String64) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v string
+	v, nTmp, err = d.DecodeString(64)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String64: %s", err)
+	}
+	*s = String64(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s String64) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1123,7 +1568,9 @@ func (s String64) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *String64) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1153,6 +1600,20 @@ func (s SequenceNumber) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SequenceNumber)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SequenceNumber) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = (*Int64)(s).DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SequenceNumber) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1163,7 +1624,9 @@ func (s SequenceNumber) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SequenceNumber) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1193,6 +1656,20 @@ func (s TimePoint) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TimePoint)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TimePoint) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = (*Uint64)(s).DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TimePoint) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1203,7 +1680,9 @@ func (s TimePoint) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TimePoint) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1238,6 +1717,20 @@ func (s DataValue) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*DataValue)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *DataValue) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	(*s), nTmp, err = d.DecodeOpaque(64)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DataValue: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s DataValue) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1248,7 +1741,9 @@ func (s DataValue) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *DataValue) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1278,6 +1773,20 @@ func (s *PoolId) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PoolId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PoolId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = (*Hash)(s).DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PoolId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1288,7 +1797,9 @@ func (s PoolId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PoolId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1323,6 +1834,20 @@ func (s *AssetCode4) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AssetCode4)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AssetCode4) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetCode4: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AssetCode4) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1333,7 +1858,9 @@ func (s AssetCode4) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AssetCode4) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1368,6 +1895,20 @@ func (s *AssetCode12) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AssetCode12)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AssetCode12) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetCode12: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AssetCode12) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1378,7 +1919,9 @@ func (s AssetCode12) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AssetCode12) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1441,6 +1984,21 @@ func (e AssetType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*AssetType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *AssetType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetType: %s", err)
+	}
+	if _, ok := assetTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid AssetType enum value", v)
+	}
+	*e = AssetType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AssetType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1451,7 +2009,9 @@ func (s AssetType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AssetType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1596,6 +2156,38 @@ func (u AssetCode) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (AssetType) switch value '%d' is not valid for union AssetCode", u.Type)
 }
 
+var _ decoderFrom = (*AssetCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AssetCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetType: %s", err)
+	}
+	switch AssetType(u.Type) {
+	case AssetTypeAssetTypeCreditAlphanum4:
+		u.AssetCode4 = new(AssetCode4)
+		nTmp, err = (*u.AssetCode4).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AssetCode4: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum12:
+		u.AssetCode12 = new(AssetCode12)
+		nTmp, err = (*u.AssetCode12).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AssetCode12: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union AssetCode has invalid Type (AssetType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AssetCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1606,7 +2198,9 @@ func (s AssetCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AssetCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1646,6 +2240,25 @@ func (s *AlphaNum4) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AlphaNum4)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AlphaNum4) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AssetCode.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetCode4: %s", err)
+	}
+	nTmp, err = s.Issuer.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AlphaNum4) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1656,7 +2269,9 @@ func (s AlphaNum4) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AlphaNum4) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1696,6 +2311,25 @@ func (s *AlphaNum12) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AlphaNum12)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AlphaNum12) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AssetCode.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetCode12: %s", err)
+	}
+	nTmp, err = s.Issuer.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AlphaNum12) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1706,7 +2340,9 @@ func (s AlphaNum12) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AlphaNum12) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1861,6 +2497,41 @@ func (u Asset) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (AssetType) switch value '%d' is not valid for union Asset", u.Type)
 }
 
+var _ decoderFrom = (*Asset)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *Asset) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetType: %s", err)
+	}
+	switch AssetType(u.Type) {
+	case AssetTypeAssetTypeNative:
+		// Void
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum4:
+		u.AlphaNum4 = new(AlphaNum4)
+		nTmp, err = (*u.AlphaNum4).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum4: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum12:
+		u.AlphaNum12 = new(AlphaNum12)
+		nTmp, err = (*u.AlphaNum12).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum12: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union Asset has invalid Type (AssetType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Asset) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1871,7 +2542,9 @@ func (s Asset) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Asset) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1911,6 +2584,25 @@ func (s *Price) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Price)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Price) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.N.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int32: %s", err)
+	}
+	nTmp, err = s.D.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Price) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1921,7 +2613,9 @@ func (s Price) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Price) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -1961,6 +2655,25 @@ func (s *Liabilities) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Liabilities)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Liabilities) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Buying.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Selling.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Liabilities) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -1971,7 +2684,9 @@ func (s Liabilities) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Liabilities) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2034,6 +2749,21 @@ func (e ThresholdIndexes) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ThresholdIndexes)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ThresholdIndexes) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ThresholdIndexes: %s", err)
+	}
+	if _, ok := thresholdIndexesMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ThresholdIndexes enum value", v)
+	}
+	*e = ThresholdIndexes(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ThresholdIndexes) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2044,7 +2774,9 @@ func (s ThresholdIndexes) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ThresholdIndexes) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2113,6 +2845,21 @@ func (e LedgerEntryType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LedgerEntryType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LedgerEntryType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryType: %s", err)
+	}
+	if _, ok := ledgerEntryTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LedgerEntryType enum value", v)
+	}
+	*e = LedgerEntryType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2123,7 +2870,9 @@ func (s LedgerEntryType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2163,6 +2912,25 @@ func (s *Signer) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Signer)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Signer) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Key.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SignerKey: %s", err)
+	}
+	nTmp, err = s.Weight.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Signer) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2173,7 +2941,9 @@ func (s Signer) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Signer) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2246,6 +3016,21 @@ func (e AccountFlags) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*AccountFlags)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *AccountFlags) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountFlags: %s", err)
+	}
+	if _, ok := accountFlagsMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid AccountFlags enum value", v)
+	}
+	*e = AccountFlags(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountFlags) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2256,7 +3041,9 @@ func (s AccountFlags) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountFlags) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2347,6 +3134,25 @@ func (u AccountEntryExtensionV2Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union AccountEntryExtensionV2Ext", u.V)
 }
 
+var _ decoderFrom = (*AccountEntryExtensionV2Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AccountEntryExtensionV2Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union AccountEntryExtensionV2Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountEntryExtensionV2Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2357,7 +3163,9 @@ func (s AccountEntryExtensionV2Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountEntryExtensionV2Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2423,6 +3231,60 @@ func (s *AccountEntryExtensionV2) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AccountEntryExtensionV2)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AccountEntryExtensionV2) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.NumSponsored.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NumSponsoring.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SponsorshipDescriptor: %s", err)
+	}
+	if l > 20 {
+		return n, fmt.Errorf("decoding SponsorshipDescriptor: data size (%d) exceeds size limit (20)", l)
+	}
+	s.SignerSponsoringIDs = nil
+	if l > 0 {
+		s.SignerSponsoringIDs = make([]SponsorshipDescriptor, l)
+		for i := uint32(0); i < l; i++ {
+			var eb bool
+			eb, nTmp, err = d.DecodeBool()
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding SponsorshipDescriptor: %s", err)
+			}
+			s.SignerSponsoringIDs[i] = nil
+			if eb {
+				s.SignerSponsoringIDs[i] = new(AccountId)
+				nTmp, err = s.SignerSponsoringIDs[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding SponsorshipDescriptor: %s", err)
+				}
+			}
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountEntryExtensionV2Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountEntryExtensionV2) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2433,7 +3295,9 @@ func (s AccountEntryExtensionV2) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountEntryExtensionV2) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2542,18 +3406,47 @@ func (u AccountEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union AccountEntryExtensionV1Ext", u.V)
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (s AccountEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
-	b := bytes.Buffer{}
-	e := xdr.NewEncoder(&b)
-	err := s.EncodeTo(e)
-	return b.Bytes(), err
-}
+var _ decoderFrom = (*AccountEntryExtensionV1Ext)(nil)
 
-// UnmarshalBinary implements encoding.BinaryUnmarshaler.
-func (s *AccountEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
-	return err
+// DecodeFrom decodes this value using the Decoder.
+func (u *AccountEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 2:
+		u.V2 = new(AccountEntryExtensionV2)
+		nTmp, err = (*u.V2).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountEntryExtensionV2: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union AccountEntryExtensionV1Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s AccountEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
+	e := xdr.NewEncoder(&b)
+	err := s.EncodeTo(e)
+	return b.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+func (s *AccountEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error {
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
+	return err
 }
 
 var (
@@ -2600,6 +3493,25 @@ func (s *AccountEntryExtensionV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AccountEntryExtensionV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AccountEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Liabilities.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Liabilities: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountEntryExtensionV1Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountEntryExtensionV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2610,7 +3522,9 @@ func (s AccountEntryExtensionV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountEntryExtensionV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2719,6 +3633,33 @@ func (u AccountEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union AccountEntryExt", u.V)
 }
 
+var _ decoderFrom = (*AccountEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AccountEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 1:
+		u.V1 = new(AccountEntryExtensionV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountEntryExtensionV1: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union AccountEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2729,7 +3670,9 @@ func (s AccountEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2834,6 +3777,90 @@ func (s *AccountEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AccountEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AccountEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Balance.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.SeqNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	nTmp, err = s.NumSubEntries.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	s.InflationDest = nil
+	if b {
+		s.InflationDest = new(AccountId)
+		nTmp, err = s.InflationDest.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountId: %s", err)
+		}
+	}
+	nTmp, err = s.Flags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.HomeDomain.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String32: %s", err)
+	}
+	nTmp, err = s.Thresholds.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Thresholds: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signer: %s", err)
+	}
+	if l > 20 {
+		return n, fmt.Errorf("decoding Signer: data size (%d) exceeds size limit (20)", l)
+	}
+	s.Signers = nil
+	if l > 0 {
+		s.Signers = make([]Signer, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Signers[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Signer: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2844,7 +3871,9 @@ func (s AccountEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2909,6 +3938,21 @@ func (e TrustLineFlags) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*TrustLineFlags)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *TrustLineFlags) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineFlags: %s", err)
+	}
+	if _, ok := trustLineFlagsMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid TrustLineFlags enum value", v)
+	}
+	*e = TrustLineFlags(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineFlags) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -2919,7 +3963,9 @@ func (s TrustLineFlags) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineFlags) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -2991,6 +4037,21 @@ func (e LiquidityPoolType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LiquidityPoolType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LiquidityPoolType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolType: %s", err)
+	}
+	if _, ok := liquidityPoolTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LiquidityPoolType enum value", v)
+	}
+	*e = LiquidityPoolType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3001,7 +4062,9 @@ func (s LiquidityPoolType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3199,6 +4262,49 @@ func (u TrustLineAsset) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (AssetType) switch value '%d' is not valid for union TrustLineAsset", u.Type)
 }
 
+var _ decoderFrom = (*TrustLineAsset)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TrustLineAsset) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetType: %s", err)
+	}
+	switch AssetType(u.Type) {
+	case AssetTypeAssetTypeNative:
+		// Void
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum4:
+		u.AlphaNum4 = new(AlphaNum4)
+		nTmp, err = (*u.AlphaNum4).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum4: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum12:
+		u.AlphaNum12 = new(AlphaNum12)
+		nTmp, err = (*u.AlphaNum12).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum12: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypePoolShare:
+		u.LiquidityPoolId = new(PoolId)
+		nTmp, err = (*u.LiquidityPoolId).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PoolId: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TrustLineAsset has invalid Type (AssetType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineAsset) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3209,7 +4315,9 @@ func (s TrustLineAsset) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineAsset) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3276,6 +4384,25 @@ func (u TrustLineEntryExtensionV2Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TrustLineEntryExtensionV2Ext", u.V)
 }
 
+var _ decoderFrom = (*TrustLineEntryExtensionV2Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TrustLineEntryExtensionV2Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TrustLineEntryExtensionV2Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntryExtensionV2Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3286,7 +4413,9 @@ func (s TrustLineEntryExtensionV2Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntryExtensionV2Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3332,6 +4461,25 @@ func (s *TrustLineEntryExtensionV2) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TrustLineEntryExtensionV2)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TrustLineEntryExtensionV2) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolUseCount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int32: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineEntryExtensionV2Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntryExtensionV2) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3342,7 +4490,9 @@ func (s TrustLineEntryExtensionV2) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntryExtensionV2) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3451,6 +4601,33 @@ func (u TrustLineEntryV1Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TrustLineEntryV1Ext", u.V)
 }
 
+var _ decoderFrom = (*TrustLineEntryV1Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TrustLineEntryV1Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 2:
+		u.V2 = new(TrustLineEntryExtensionV2)
+		nTmp, err = (*u.V2).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TrustLineEntryExtensionV2: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TrustLineEntryV1Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntryV1Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3461,7 +4638,9 @@ func (s TrustLineEntryV1Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntryV1Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3509,6 +4688,25 @@ func (s *TrustLineEntryV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TrustLineEntryV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TrustLineEntryV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Liabilities.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Liabilities: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineEntryV1Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntryV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3519,7 +4717,9 @@ func (s TrustLineEntryV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntryV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3640,6 +4840,33 @@ func (u TrustLineEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TrustLineEntryExt", u.V)
 }
 
+var _ decoderFrom = (*TrustLineEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TrustLineEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 1:
+		u.V1 = new(TrustLineEntryV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TrustLineEntryV1: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TrustLineEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3650,7 +4877,9 @@ func (s TrustLineEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3733,6 +4962,45 @@ func (s *TrustLineEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TrustLineEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TrustLineEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineAsset: %s", err)
+	}
+	nTmp, err = s.Balance.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Limit.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Flags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TrustLineEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3743,7 +5011,9 @@ func (s TrustLineEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TrustLineEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3798,6 +5068,21 @@ func (e OfferEntryFlags) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*OfferEntryFlags)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *OfferEntryFlags) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding OfferEntryFlags: %s", err)
+	}
+	if _, ok := offerEntryFlagsMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid OfferEntryFlags enum value", v)
+	}
+	*e = OfferEntryFlags(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OfferEntryFlags) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3808,7 +5093,9 @@ func (s OfferEntryFlags) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OfferEntryFlags) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3881,6 +5168,25 @@ func (u OfferEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union OfferEntryExt", u.V)
 }
 
+var _ decoderFrom = (*OfferEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *OfferEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union OfferEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OfferEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3891,7 +5197,9 @@ func (s OfferEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OfferEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -3974,6 +5282,55 @@ func (s *OfferEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*OfferEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *OfferEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SellerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Selling.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Buying.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Price.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	nTmp, err = s.Flags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OfferEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OfferEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -3984,7 +5341,9 @@ func (s OfferEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OfferEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4051,6 +5410,25 @@ func (u DataEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union DataEntryExt", u.V)
 }
 
+var _ decoderFrom = (*DataEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *DataEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union DataEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s DataEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4061,7 +5439,9 @@ func (s DataEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *DataEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4118,6 +5498,35 @@ func (s *DataEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*DataEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *DataEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.DataName.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String64: %s", err)
+	}
+	nTmp, err = s.DataValue.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DataValue: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DataEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s DataEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4128,7 +5537,9 @@ func (s DataEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *DataEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4197,6 +5608,21 @@ func (e ClaimPredicateType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimPredicateType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimPredicateType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimPredicateType: %s", err)
+	}
+	if _, ok := claimPredicateTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimPredicateType enum value", v)
+	}
+	*e = ClaimPredicateType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimPredicateType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4207,7 +5633,9 @@ func (s ClaimPredicateType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimPredicateType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4500,6 +5928,105 @@ func (u ClaimPredicate) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (ClaimPredicateType) switch value '%d' is not valid for union ClaimPredicate", u.Type)
 }
 
+var _ decoderFrom = (*ClaimPredicate)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimPredicate) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimPredicateType: %s", err)
+	}
+	switch ClaimPredicateType(u.Type) {
+	case ClaimPredicateTypeClaimPredicateUnconditional:
+		// Void
+		return n, nil
+	case ClaimPredicateTypeClaimPredicateAnd:
+		u.AndPredicates = new([]ClaimPredicate)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+		}
+		if l > 2 {
+			return n, fmt.Errorf("decoding ClaimPredicate: data size (%d) exceeds size limit (2)", l)
+		}
+		(*u.AndPredicates) = nil
+		if l > 0 {
+			(*u.AndPredicates) = make([]ClaimPredicate, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.AndPredicates)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case ClaimPredicateTypeClaimPredicateOr:
+		u.OrPredicates = new([]ClaimPredicate)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+		}
+		if l > 2 {
+			return n, fmt.Errorf("decoding ClaimPredicate: data size (%d) exceeds size limit (2)", l)
+		}
+		(*u.OrPredicates) = nil
+		if l > 0 {
+			(*u.OrPredicates) = make([]ClaimPredicate, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.OrPredicates)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case ClaimPredicateTypeClaimPredicateNot:
+		u.NotPredicate = new(*ClaimPredicate)
+		var b bool
+		b, nTmp, err = d.DecodeBool()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+		}
+		(*u.NotPredicate) = nil
+		if b {
+			(*u.NotPredicate) = new(ClaimPredicate)
+			nTmp, err = (*u.NotPredicate).DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+			}
+		}
+		return n, nil
+	case ClaimPredicateTypeClaimPredicateBeforeAbsoluteTime:
+		u.AbsBefore = new(Int64)
+		nTmp, err = (*u.AbsBefore).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Int64: %s", err)
+		}
+		return n, nil
+	case ClaimPredicateTypeClaimPredicateBeforeRelativeTime:
+		u.RelBefore = new(Int64)
+		nTmp, err = (*u.RelBefore).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Int64: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ClaimPredicate has invalid Type (ClaimPredicateType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimPredicate) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4510,7 +6037,9 @@ func (s ClaimPredicate) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimPredicate) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4564,6 +6093,21 @@ func (e ClaimantType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimantType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimantType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimantType: %s", err)
+	}
+	if _, ok := claimantTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimantType enum value", v)
+	}
+	*e = ClaimantType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimantType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4574,7 +6118,9 @@ func (s ClaimantType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimantType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4614,6 +6160,25 @@ func (s *ClaimantV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimantV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimantV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Predicate.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimPredicate: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimantV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4624,7 +6189,9 @@ func (s ClaimantV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimantV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4728,6 +6295,30 @@ func (u Claimant) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (ClaimantType) switch value '%d' is not valid for union Claimant", u.Type)
 }
 
+var _ decoderFrom = (*Claimant)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *Claimant) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimantType: %s", err)
+	}
+	switch ClaimantType(u.Type) {
+	case ClaimantTypeClaimantTypeV0:
+		u.V0 = new(ClaimantV0)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimantV0: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union Claimant has invalid Type (ClaimantType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Claimant) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4738,7 +6329,9 @@ func (s Claimant) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Claimant) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4792,6 +6385,21 @@ func (e ClaimableBalanceIdType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimableBalanceIdType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimableBalanceIdType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceIdType: %s", err)
+	}
+	if _, ok := claimableBalanceIdTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimableBalanceIdType enum value", v)
+	}
+	*e = ClaimableBalanceIdType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceIdType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4802,7 +6410,9 @@ func (s ClaimableBalanceIdType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceIdType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4902,6 +6512,30 @@ func (u ClaimableBalanceId) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (ClaimableBalanceIdType) switch value '%d' is not valid for union ClaimableBalanceId", u.Type)
 }
 
+var _ decoderFrom = (*ClaimableBalanceId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimableBalanceId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceIdType: %s", err)
+	}
+	switch ClaimableBalanceIdType(u.Type) {
+	case ClaimableBalanceIdTypeClaimableBalanceIdTypeV0:
+		u.V0 = new(Hash)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Hash: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ClaimableBalanceId has invalid Type (ClaimableBalanceIdType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4912,7 +6546,9 @@ func (s ClaimableBalanceId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -4968,6 +6604,21 @@ func (e ClaimableBalanceFlags) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimableBalanceFlags)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimableBalanceFlags) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceFlags: %s", err)
+	}
+	if _, ok := claimableBalanceFlagsMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimableBalanceFlags enum value", v)
+	}
+	*e = ClaimableBalanceFlags(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceFlags) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -4978,7 +6629,9 @@ func (s ClaimableBalanceFlags) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceFlags) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5051,6 +6704,25 @@ func (u ClaimableBalanceEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union ClaimableBalanceEntryExtensionV1Ext", u.V)
 }
 
+var _ decoderFrom = (*ClaimableBalanceEntryExtensionV1Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimableBalanceEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union ClaimableBalanceEntryExtensionV1Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5061,7 +6733,9 @@ func (s ClaimableBalanceEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5107,6 +6781,25 @@ func (s *ClaimableBalanceEntryExtensionV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimableBalanceEntryExtensionV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimableBalanceEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceEntryExtensionV1Ext: %s", err)
+	}
+	nTmp, err = s.Flags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceEntryExtensionV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5117,7 +6810,9 @@ func (s ClaimableBalanceEntryExtensionV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceEntryExtensionV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5226,17 +6921,46 @@ func (u ClaimableBalanceEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union ClaimableBalanceEntryExt", u.V)
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (s ClaimableBalanceEntryExt) MarshalBinary() ([]byte, error) {
-	b := bytes.Buffer{}
-	e := xdr.NewEncoder(&b)
-	err := s.EncodeTo(e)
-	return b.Bytes(), err
+var _ decoderFrom = (*ClaimableBalanceEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimableBalanceEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 1:
+		u.V1 = new(ClaimableBalanceEntryExtensionV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimableBalanceEntryExtensionV1: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ClaimableBalanceEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s ClaimableBalanceEntryExt) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
+	e := xdr.NewEncoder(&b)
+	err := s.EncodeTo(e)
+	return b.Bytes(), err
 }
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5312,6 +7036,55 @@ func (s *ClaimableBalanceEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimableBalanceEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimableBalanceEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.BalanceId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceId: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Claimant: %s", err)
+	}
+	if l > 10 {
+		return n, fmt.Errorf("decoding Claimant: data size (%d) exceeds size limit (10)", l)
+	}
+	s.Claimants = nil
+	if l > 0 {
+		s.Claimants = make([]Claimant, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Claimants[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Claimant: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimableBalanceEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5322,7 +7095,9 @@ func (s ClaimableBalanceEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimableBalanceEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5367,6 +7142,30 @@ func (s *LiquidityPoolConstantProductParameters) EncodeTo(e *xdr.Encoder) error
 	return nil
 }
 
+var _ decoderFrom = (*LiquidityPoolConstantProductParameters)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LiquidityPoolConstantProductParameters) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AssetA.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AssetB.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Fee.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolConstantProductParameters) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5377,7 +7176,9 @@ func (s LiquidityPoolConstantProductParameters) MarshalBinary() ([]byte, error)
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolConstantProductParameters) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5433,6 +7234,40 @@ func (s *LiquidityPoolEntryConstantProduct) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LiquidityPoolEntryConstantProduct)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LiquidityPoolEntryConstantProduct) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Params.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolConstantProductParameters: %s", err)
+	}
+	nTmp, err = s.ReserveA.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.ReserveB.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.TotalPoolShares.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.PoolSharesTrustLineCount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolEntryConstantProduct) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5443,7 +7278,9 @@ func (s LiquidityPoolEntryConstantProduct) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolEntryConstantProduct) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5551,6 +7388,30 @@ func (u LiquidityPoolEntryBody) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LiquidityPoolType) switch value '%d' is not valid for union LiquidityPoolEntryBody", u.Type)
 }
 
+var _ decoderFrom = (*LiquidityPoolEntryBody)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LiquidityPoolEntryBody) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolType: %s", err)
+	}
+	switch LiquidityPoolType(u.Type) {
+	case LiquidityPoolTypeLiquidityPoolConstantProduct:
+		u.ConstantProduct = new(LiquidityPoolEntryConstantProduct)
+		nTmp, err = (*u.ConstantProduct).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolEntryConstantProduct: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LiquidityPoolEntryBody has invalid Type (LiquidityPoolType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolEntryBody) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5561,7 +7422,9 @@ func (s LiquidityPoolEntryBody) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolEntryBody) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5615,6 +7478,25 @@ func (s *LiquidityPoolEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LiquidityPoolEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LiquidityPoolEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	nTmp, err = s.Body.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolEntryBody: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5625,7 +7507,9 @@ func (s LiquidityPoolEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5692,6 +7576,25 @@ func (u LedgerEntryExtensionV1Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerEntryExtensionV1Ext", u.V)
 }
 
+var _ decoderFrom = (*LedgerEntryExtensionV1Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerEntryExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerEntryExtensionV1Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5702,7 +7605,9 @@ func (s LedgerEntryExtensionV1Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryExtensionV1Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -5753,6 +7658,35 @@ func (s *LedgerEntryExtensionV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerEntryExtensionV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerEntryExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SponsorshipDescriptor: %s", err)
+	}
+	s.SponsoringId = nil
+	if b {
+		s.SponsoringId = new(AccountId)
+		nTmp, err = s.SponsoringId.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SponsorshipDescriptor: %s", err)
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryExtensionV1Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryExtensionV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -5763,7 +7697,9 @@ func (s LedgerEntryExtensionV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryExtensionV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6073,6 +8009,70 @@ func (u LedgerEntryData) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LedgerEntryType) switch value '%d' is not valid for union LedgerEntryData", u.Type)
 }
 
+var _ decoderFrom = (*LedgerEntryData)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerEntryData) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryType: %s", err)
+	}
+	switch LedgerEntryType(u.Type) {
+	case LedgerEntryTypeAccount:
+		u.Account = new(AccountEntry)
+		nTmp, err = (*u.Account).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeTrustline:
+		u.TrustLine = new(TrustLineEntry)
+		nTmp, err = (*u.TrustLine).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TrustLineEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeOffer:
+		u.Offer = new(OfferEntry)
+		nTmp, err = (*u.Offer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OfferEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeData:
+		u.Data = new(DataEntry)
+		nTmp, err = (*u.Data).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding DataEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeClaimableBalance:
+		u.ClaimableBalance = new(ClaimableBalanceEntry)
+		nTmp, err = (*u.ClaimableBalance).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimableBalanceEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeLiquidityPool:
+		u.LiquidityPool = new(LiquidityPoolEntry)
+		nTmp, err = (*u.LiquidityPool).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolEntry: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerEntryData has invalid Type (LedgerEntryType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryData) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6083,7 +8083,9 @@ func (s LedgerEntryData) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryData) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6192,6 +8194,33 @@ func (u LedgerEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerEntryExt", u.V)
 }
 
+var _ decoderFrom = (*LedgerEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 1:
+		u.V1 = new(LedgerEntryExtensionV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntryExtensionV1: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6202,7 +8231,9 @@ func (s LedgerEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6272,6 +8303,30 @@ func (s *LedgerEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LastModifiedLedgerSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Data.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryData: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6282,7 +8337,9 @@ func (s LedgerEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6317,6 +8374,20 @@ func (s *LedgerKeyAccount) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyAccount)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyAccount) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyAccount) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6327,7 +8398,9 @@ func (s LedgerKeyAccount) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyAccount) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6367,6 +8440,25 @@ func (s *LedgerKeyTrustLine) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyTrustLine)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyTrustLine) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TrustLineAsset: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyTrustLine) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6377,7 +8469,9 @@ func (s LedgerKeyTrustLine) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyTrustLine) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6417,6 +8511,25 @@ func (s *LedgerKeyOffer) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyOffer)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyOffer) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SellerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyOffer) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6427,7 +8540,9 @@ func (s LedgerKeyOffer) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyOffer) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6467,6 +8582,25 @@ func (s *LedgerKeyData) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyData)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyData) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.DataName.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyData) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6477,7 +8611,9 @@ func (s LedgerKeyData) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyData) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6512,6 +8648,20 @@ func (s *LedgerKeyClaimableBalance) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyClaimableBalance)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyClaimableBalance) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.BalanceId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyClaimableBalance) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6522,7 +8672,9 @@ func (s LedgerKeyClaimableBalance) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyClaimableBalance) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6557,6 +8709,20 @@ func (s *LedgerKeyLiquidityPool) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerKeyLiquidityPool)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerKeyLiquidityPool) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKeyLiquidityPool) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6567,7 +8733,9 @@ func (s LedgerKeyLiquidityPool) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKeyLiquidityPool) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6903,6 +9071,70 @@ func (u LedgerKey) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LedgerEntryType) switch value '%d' is not valid for union LedgerKey", u.Type)
 }
 
+var _ decoderFrom = (*LedgerKey)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerKey) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryType: %s", err)
+	}
+	switch LedgerEntryType(u.Type) {
+	case LedgerEntryTypeAccount:
+		u.Account = new(LedgerKeyAccount)
+		nTmp, err = (*u.Account).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyAccount: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeTrustline:
+		u.TrustLine = new(LedgerKeyTrustLine)
+		nTmp, err = (*u.TrustLine).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyTrustLine: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeOffer:
+		u.Offer = new(LedgerKeyOffer)
+		nTmp, err = (*u.Offer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyOffer: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeData:
+		u.Data = new(LedgerKeyData)
+		nTmp, err = (*u.Data).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyData: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeClaimableBalance:
+		u.ClaimableBalance = new(LedgerKeyClaimableBalance)
+		nTmp, err = (*u.ClaimableBalance).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyClaimableBalance: %s", err)
+		}
+		return n, nil
+	case LedgerEntryTypeLiquidityPool:
+		u.LiquidityPool = new(LedgerKeyLiquidityPool)
+		nTmp, err = (*u.LiquidityPool).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKeyLiquidityPool: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerKey has invalid Type (LedgerEntryType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerKey) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6913,7 +9145,9 @@ func (s LedgerKey) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerKey) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -6988,6 +9222,21 @@ func (e EnvelopeType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*EnvelopeType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *EnvelopeType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding EnvelopeType: %s", err)
+	}
+	if _, ok := envelopeTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid EnvelopeType enum value", v)
+	}
+	*e = EnvelopeType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s EnvelopeType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -6998,7 +9247,9 @@ func (s EnvelopeType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *EnvelopeType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7033,6 +9284,20 @@ func (s UpgradeType) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*UpgradeType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *UpgradeType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	(*s), nTmp, err = d.DecodeOpaque(128)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding UpgradeType: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s UpgradeType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7043,7 +9308,9 @@ func (s UpgradeType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *UpgradeType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7100,6 +9367,21 @@ func (e StellarValueType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*StellarValueType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *StellarValueType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding StellarValueType: %s", err)
+	}
+	if _, ok := stellarValueTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid StellarValueType enum value", v)
+	}
+	*e = StellarValueType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s StellarValueType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7110,7 +9392,9 @@ func (s StellarValueType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *StellarValueType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7150,6 +9434,25 @@ func (s *LedgerCloseValueSignature) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerCloseValueSignature)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerCloseValueSignature) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.NodeId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.Signature.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerCloseValueSignature) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7160,7 +9463,9 @@ func (s LedgerCloseValueSignature) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerCloseValueSignature) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7269,6 +9574,33 @@ func (u StellarValueExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (StellarValueType) switch value '%d' is not valid for union StellarValueExt", u.V)
 }
 
+var _ decoderFrom = (*StellarValueExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *StellarValueExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.V.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding StellarValueType: %s", err)
+	}
+	switch StellarValueType(u.V) {
+	case StellarValueTypeStellarValueBasic:
+		// Void
+		return n, nil
+	case StellarValueTypeStellarValueSigned:
+		u.LcValueSignature = new(LedgerCloseValueSignature)
+		nTmp, err = (*u.LcValueSignature).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerCloseValueSignature: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union StellarValueExt has invalid V (StellarValueType) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s StellarValueExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7279,7 +9611,9 @@ func (s StellarValueExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *StellarValueExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7349,6 +9683,50 @@ func (s *StellarValue) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*StellarValue)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *StellarValue) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.TxSetHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.CloseTime.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TimePoint: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding UpgradeType: %s", err)
+	}
+	if l > 6 {
+		return n, fmt.Errorf("decoding UpgradeType: data size (%d) exceeds size limit (6)", l)
+	}
+	s.Upgrades = nil
+	if l > 0 {
+		s.Upgrades = make([]UpgradeType, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Upgrades[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding UpgradeType: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding StellarValueExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s StellarValue) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7359,7 +9737,9 @@ func (s StellarValue) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *StellarValue) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7425,6 +9805,21 @@ func (e LedgerHeaderFlags) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LedgerHeaderFlags)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LedgerHeaderFlags) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeaderFlags: %s", err)
+	}
+	if _, ok := ledgerHeaderFlagsMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LedgerHeaderFlags enum value", v)
+	}
+	*e = LedgerHeaderFlags(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderFlags) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7435,7 +9830,9 @@ func (s LedgerHeaderFlags) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderFlags) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7502,6 +9899,25 @@ func (u LedgerHeaderExtensionV1Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerHeaderExtensionV1Ext", u.V)
 }
 
+var _ decoderFrom = (*LedgerHeaderExtensionV1Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerHeaderExtensionV1Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerHeaderExtensionV1Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderExtensionV1Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7512,7 +9928,9 @@ func (s LedgerHeaderExtensionV1Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderExtensionV1Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7558,6 +9976,25 @@ func (s *LedgerHeaderExtensionV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerHeaderExtensionV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerHeaderExtensionV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Flags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeaderExtensionV1Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderExtensionV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7568,7 +10005,9 @@ func (s LedgerHeaderExtensionV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderExtensionV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7677,6 +10116,33 @@ func (u LedgerHeaderExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerHeaderExt", u.V)
 }
 
+var _ decoderFrom = (*LedgerHeaderExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerHeaderExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	case 1:
+		u.V1 = new(LedgerHeaderExtensionV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerHeaderExtensionV1: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerHeaderExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7687,7 +10153,9 @@ func (s LedgerHeaderExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7815,6 +10283,92 @@ func (s *LedgerHeader) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerHeader)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerHeader) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerVersion.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.PreviousLedgerHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.ScpValue.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding StellarValue: %s", err)
+	}
+	nTmp, err = s.TxSetResultHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.BucketListHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.LedgerSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.TotalCoins.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.FeePool.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.InflationSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.IdPool.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.BaseFee.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.BaseReserve.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.MaxTxSetSize.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	for i := 0; i < len(s.SkipList); i++ {
+		nTmp, err = s.SkipList[i].DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Hash: %s", err)
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeaderExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeader) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7825,7 +10379,9 @@ func (s LedgerHeader) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeader) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -7891,6 +10447,21 @@ func (e LedgerUpgradeType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LedgerUpgradeType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LedgerUpgradeType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerUpgradeType: %s", err)
+	}
+	if _, ok := ledgerUpgradeTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LedgerUpgradeType enum value", v)
+	}
+	*e = LedgerUpgradeType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerUpgradeType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -7901,7 +10472,9 @@ func (s LedgerUpgradeType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerUpgradeType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8169,17 +10742,75 @@ func (u LedgerUpgrade) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LedgerUpgradeType) switch value '%d' is not valid for union LedgerUpgrade", u.Type)
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (s LedgerUpgrade) MarshalBinary() ([]byte, error) {
-	b := bytes.Buffer{}
-	e := xdr.NewEncoder(&b)
-	err := s.EncodeTo(e)
+var _ decoderFrom = (*LedgerUpgrade)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerUpgrade) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerUpgradeType: %s", err)
+	}
+	switch LedgerUpgradeType(u.Type) {
+	case LedgerUpgradeTypeLedgerUpgradeVersion:
+		u.NewLedgerVersion = new(Uint32)
+		nTmp, err = (*u.NewLedgerVersion).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	case LedgerUpgradeTypeLedgerUpgradeBaseFee:
+		u.NewBaseFee = new(Uint32)
+		nTmp, err = (*u.NewBaseFee).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	case LedgerUpgradeTypeLedgerUpgradeMaxTxSetSize:
+		u.NewMaxTxSetSize = new(Uint32)
+		nTmp, err = (*u.NewMaxTxSetSize).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	case LedgerUpgradeTypeLedgerUpgradeBaseReserve:
+		u.NewBaseReserve = new(Uint32)
+		nTmp, err = (*u.NewBaseReserve).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	case LedgerUpgradeTypeLedgerUpgradeFlags:
+		u.NewFlags = new(Uint32)
+		nTmp, err = (*u.NewFlags).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerUpgrade has invalid Type (LedgerUpgradeType) switch value '%d'", u.Type)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s LedgerUpgrade) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
+	e := xdr.NewEncoder(&b)
+	err := s.EncodeTo(e)
 	return b.Bytes(), err
 }
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerUpgrade) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8244,6 +10875,21 @@ func (e BucketEntryType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*BucketEntryType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *BucketEntryType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding BucketEntryType: %s", err)
+	}
+	if _, ok := bucketEntryTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid BucketEntryType enum value", v)
+	}
+	*e = BucketEntryType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BucketEntryType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8254,7 +10900,9 @@ func (s BucketEntryType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BucketEntryType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8321,6 +10969,25 @@ func (u BucketMetadataExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union BucketMetadataExt", u.V)
 }
 
+var _ decoderFrom = (*BucketMetadataExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *BucketMetadataExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union BucketMetadataExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BucketMetadataExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8331,7 +10998,9 @@ func (s BucketMetadataExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BucketMetadataExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8379,6 +11048,25 @@ func (s *BucketMetadata) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*BucketMetadata)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *BucketMetadata) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerVersion.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding BucketMetadataExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BucketMetadata) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8389,7 +11077,9 @@ func (s BucketMetadata) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BucketMetadata) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8589,6 +11279,54 @@ func (u BucketEntry) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (BucketEntryType) switch value '%d' is not valid for union BucketEntry", u.Type)
 }
 
+var _ decoderFrom = (*BucketEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *BucketEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding BucketEntryType: %s", err)
+	}
+	switch BucketEntryType(u.Type) {
+	case BucketEntryTypeLiveentry:
+		u.LiveEntry = new(LedgerEntry)
+		nTmp, err = (*u.LiveEntry).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntry: %s", err)
+		}
+		return n, nil
+	case BucketEntryTypeInitentry:
+		u.LiveEntry = new(LedgerEntry)
+		nTmp, err = (*u.LiveEntry).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntry: %s", err)
+		}
+		return n, nil
+	case BucketEntryTypeDeadentry:
+		u.DeadEntry = new(LedgerKey)
+		nTmp, err = (*u.DeadEntry).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKey: %s", err)
+		}
+		return n, nil
+	case BucketEntryTypeMetaentry:
+		u.MetaEntry = new(BucketMetadata)
+		nTmp, err = (*u.MetaEntry).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding BucketMetadata: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union BucketEntry has invalid Type (BucketEntryType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BucketEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8599,7 +11337,9 @@ func (s BucketEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BucketEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8644,6 +11384,37 @@ func (s *TransactionSet) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionSet)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionSet) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.PreviousLedgerHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionEnvelope: %s", err)
+	}
+	s.Txs = nil
+	if l > 0 {
+		s.Txs = make([]TransactionEnvelope, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Txs[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding TransactionEnvelope: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionSet) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8654,7 +11425,9 @@ func (s TransactionSet) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionSet) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8694,6 +11467,25 @@ func (s *TransactionResultPair) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionResultPair)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionResultPair) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.TransactionHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.Result.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResult: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultPair) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8704,7 +11496,9 @@ func (s TransactionResultPair) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultPair) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8744,6 +11538,32 @@ func (s *TransactionResultSet) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionResultSet)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionResultSet) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultPair: %s", err)
+	}
+	s.Results = nil
+	if l > 0 {
+		s.Results = make([]TransactionResultPair, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Results[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding TransactionResultPair: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultSet) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8754,7 +11574,9 @@ func (s TransactionResultSet) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultSet) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8821,6 +11643,25 @@ func (u TransactionHistoryEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionHistoryEntryExt", u.V)
 }
 
+var _ decoderFrom = (*TransactionHistoryEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionHistoryEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionHistoryEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionHistoryEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8831,7 +11672,9 @@ func (s TransactionHistoryEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionHistoryEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8883,6 +11726,30 @@ func (s *TransactionHistoryEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionHistoryEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.TxSet.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionSet: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionHistoryEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionHistoryEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8893,7 +11760,9 @@ func (s TransactionHistoryEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionHistoryEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -8960,6 +11829,25 @@ func (u TransactionHistoryResultEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionHistoryResultEntryExt", u.V)
 }
 
+var _ decoderFrom = (*TransactionHistoryResultEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionHistoryResultEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionHistoryResultEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionHistoryResultEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -8970,7 +11858,9 @@ func (s TransactionHistoryResultEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionHistoryResultEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9022,6 +11912,30 @@ func (s *TransactionHistoryResultEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionHistoryResultEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionHistoryResultEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.TxResultSet.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultSet: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionHistoryResultEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionHistoryResultEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9032,7 +11946,9 @@ func (s TransactionHistoryResultEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionHistoryResultEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9099,6 +12015,25 @@ func (u LedgerHeaderHistoryEntryExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerHeaderHistoryEntryExt", u.V)
 }
 
+var _ decoderFrom = (*LedgerHeaderHistoryEntryExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerHeaderHistoryEntryExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerHeaderHistoryEntryExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderHistoryEntryExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9109,7 +12044,9 @@ func (s LedgerHeaderHistoryEntryExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderHistoryEntryExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9161,6 +12098,30 @@ func (s *LedgerHeaderHistoryEntry) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerHeaderHistoryEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerHeaderHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Hash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.Header.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeader: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeaderHistoryEntryExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerHeaderHistoryEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9171,7 +12132,9 @@ func (s LedgerHeaderHistoryEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerHeaderHistoryEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9216,6 +12179,37 @@ func (s *LedgerScpMessages) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerScpMessages)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerScpMessages) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerSeq.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpEnvelope: %s", err)
+	}
+	s.Messages = nil
+	if l > 0 {
+		s.Messages = make([]ScpEnvelope, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Messages[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ScpEnvelope: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerScpMessages) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9226,7 +12220,9 @@ func (s LedgerScpMessages) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerScpMessages) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9271,6 +12267,37 @@ func (s *ScpHistoryEntryV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ScpHistoryEntryV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ScpHistoryEntryV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpQuorumSet: %s", err)
+	}
+	s.QuorumSets = nil
+	if l > 0 {
+		s.QuorumSets = make([]ScpQuorumSet, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.QuorumSets[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ScpQuorumSet: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.LedgerMessages.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerScpMessages: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpHistoryEntryV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9281,7 +12308,9 @@ func (s ScpHistoryEntryV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpHistoryEntryV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9381,6 +12410,30 @@ func (u ScpHistoryEntry) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union ScpHistoryEntry", u.V)
 }
 
+var _ decoderFrom = (*ScpHistoryEntry)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ScpHistoryEntry) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		u.V0 = new(ScpHistoryEntryV0)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpHistoryEntryV0: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ScpHistoryEntry has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ScpHistoryEntry) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9391,7 +12444,9 @@ func (s ScpHistoryEntry) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ScpHistoryEntry) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9454,6 +12509,21 @@ func (e LedgerEntryChangeType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LedgerEntryChangeType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LedgerEntryChangeType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChangeType: %s", err)
+	}
+	if _, ok := ledgerEntryChangeTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LedgerEntryChangeType enum value", v)
+	}
+	*e = LedgerEntryChangeType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryChangeType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9464,7 +12534,9 @@ func (s LedgerEntryChangeType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryChangeType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9690,6 +12762,54 @@ func (u LedgerEntryChange) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LedgerEntryChangeType) switch value '%d' is not valid for union LedgerEntryChange", u.Type)
 }
 
+var _ decoderFrom = (*LedgerEntryChange)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerEntryChange) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChangeType: %s", err)
+	}
+	switch LedgerEntryChangeType(u.Type) {
+	case LedgerEntryChangeTypeLedgerEntryCreated:
+		u.Created = new(LedgerEntry)
+		nTmp, err = (*u.Created).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryChangeTypeLedgerEntryUpdated:
+		u.Updated = new(LedgerEntry)
+		nTmp, err = (*u.Updated).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntry: %s", err)
+		}
+		return n, nil
+	case LedgerEntryChangeTypeLedgerEntryRemoved:
+		u.Removed = new(LedgerKey)
+		nTmp, err = (*u.Removed).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKey: %s", err)
+		}
+		return n, nil
+	case LedgerEntryChangeTypeLedgerEntryState:
+		u.State = new(LedgerEntry)
+		nTmp, err = (*u.State).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerEntry: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerEntryChange has invalid Type (LedgerEntryChangeType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryChange) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9700,7 +12820,9 @@ func (s LedgerEntryChange) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryChange) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9735,6 +12857,32 @@ func (s LedgerEntryChanges) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerEntryChanges)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerEntryChanges) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChange: %s", err)
+	}
+	(*s) = nil
+	if l > 0 {
+		(*s) = make([]LedgerEntryChange, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = (*s)[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding LedgerEntryChange: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerEntryChanges) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9745,7 +12893,9 @@ func (s LedgerEntryChanges) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerEntryChanges) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9780,6 +12930,20 @@ func (s *OperationMeta) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*OperationMeta)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *OperationMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Changes.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationMeta) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9790,7 +12954,9 @@ func (s OperationMeta) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationMeta) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9835,6 +13001,37 @@ func (s *TransactionMetaV1) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionMetaV1)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionMetaV1) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.TxChanges.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationMeta: %s", err)
+	}
+	s.Operations = nil
+	if l > 0 {
+		s.Operations = make([]OperationMeta, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Operations[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding OperationMeta: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionMetaV1) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9845,7 +13042,9 @@ func (s TransactionMetaV1) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionMetaV1) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -9897,6 +13096,42 @@ func (s *TransactionMetaV2) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionMetaV2)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionMetaV2) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.TxChangesBefore.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationMeta: %s", err)
+	}
+	s.Operations = nil
+	if l > 0 {
+		s.Operations = make([]OperationMeta, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Operations[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding OperationMeta: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.TxChangesAfter.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionMetaV2) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -9907,7 +13142,9 @@ func (s TransactionMetaV2) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionMetaV2) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10096,6 +13333,58 @@ func (u TransactionMeta) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionMeta", u.V)
 }
 
+var _ decoderFrom = (*TransactionMeta)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		u.Operations = new([]OperationMeta)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationMeta: %s", err)
+		}
+		(*u.Operations) = nil
+		if l > 0 {
+			(*u.Operations) = make([]OperationMeta, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Operations)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding OperationMeta: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case 1:
+		u.V1 = new(TransactionMetaV1)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionMetaV1: %s", err)
+		}
+		return n, nil
+	case 2:
+		u.V2 = new(TransactionMetaV2)
+		nTmp, err = (*u.V2).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionMetaV2: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionMeta has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionMeta) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10106,7 +13395,9 @@ func (s TransactionMeta) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionMeta) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10151,6 +13442,30 @@ func (s *TransactionResultMeta) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionResultMeta)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionResultMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Result.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultPair: %s", err)
+	}
+	nTmp, err = s.FeeProcessing.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	nTmp, err = s.TxApplyProcessing.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionMeta: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultMeta) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10161,7 +13476,9 @@ func (s TransactionResultMeta) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultMeta) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10201,6 +13518,25 @@ func (s *UpgradeEntryMeta) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*UpgradeEntryMeta)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *UpgradeEntryMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Upgrade.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerUpgrade: %s", err)
+	}
+	nTmp, err = s.Changes.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerEntryChanges: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s UpgradeEntryMeta) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10211,7 +13547,9 @@ func (s UpgradeEntryMeta) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *UpgradeEntryMeta) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10290,6 +13628,74 @@ func (s *LedgerCloseMetaV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LedgerCloseMetaV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LedgerCloseMetaV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerHeader.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LedgerHeaderHistoryEntry: %s", err)
+	}
+	nTmp, err = s.TxSet.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionSet: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultMeta: %s", err)
+	}
+	s.TxProcessing = nil
+	if l > 0 {
+		s.TxProcessing = make([]TransactionResultMeta, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.TxProcessing[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding TransactionResultMeta: %s", err)
+			}
+		}
+	}
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding UpgradeEntryMeta: %s", err)
+	}
+	s.UpgradesProcessing = nil
+	if l > 0 {
+		s.UpgradesProcessing = make([]UpgradeEntryMeta, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.UpgradesProcessing[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding UpgradeEntryMeta: %s", err)
+			}
+		}
+	}
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ScpHistoryEntry: %s", err)
+	}
+	s.ScpInfo = nil
+	if l > 0 {
+		s.ScpInfo = make([]ScpHistoryEntry, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.ScpInfo[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ScpHistoryEntry: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LedgerCloseMetaV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10300,7 +13706,9 @@ func (s LedgerCloseMetaV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerCloseMetaV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10400,17 +13808,43 @@ func (u LedgerCloseMeta) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union LedgerCloseMeta", u.V)
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (s LedgerCloseMeta) MarshalBinary() ([]byte, error) {
-	b := bytes.Buffer{}
-	e := xdr.NewEncoder(&b)
-	err := s.EncodeTo(e)
-	return b.Bytes(), err
-}
+var _ decoderFrom = (*LedgerCloseMeta)(nil)
 
-// UnmarshalBinary implements encoding.BinaryUnmarshaler.
+// DecodeFrom decodes this value using the Decoder.
+func (u *LedgerCloseMeta) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		u.V0 = new(LedgerCloseMetaV0)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerCloseMetaV0: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LedgerCloseMeta has invalid V (int32) switch value '%d'", u.V)
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s LedgerCloseMeta) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
+	e := xdr.NewEncoder(&b)
+	err := s.EncodeTo(e)
+	return b.Bytes(), err
+}
+
+// UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LedgerCloseMeta) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10476,6 +13910,21 @@ func (e ErrorCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ErrorCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ErrorCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ErrorCode: %s", err)
+	}
+	if _, ok := errorCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ErrorCode enum value", v)
+	}
+	*e = ErrorCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ErrorCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10486,7 +13935,9 @@ func (s ErrorCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ErrorCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10526,6 +13977,25 @@ func (s *Error) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Error)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Error) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ErrorCode: %s", err)
+	}
+	s.Msg, nTmp, err = d.DecodeString(100)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Msg: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Error) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10536,7 +14006,9 @@ func (s Error) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Error) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10581,6 +14053,30 @@ func (s *AuthCert) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AuthCert)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AuthCert) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Pubkey.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Curve25519Public: %s", err)
+	}
+	nTmp, err = s.Expiration.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.Sig.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AuthCert) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10591,7 +14087,9 @@ func (s AuthCert) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AuthCert) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10666,6 +14164,60 @@ func (s *Hello) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Hello)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Hello) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LedgerVersion.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.OverlayVersion.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.OverlayMinVersion.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NetworkId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	s.VersionStr, nTmp, err = d.DecodeString(100)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding VersionStr: %s", err)
+	}
+	s.ListeningPort, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	nTmp, err = s.PeerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.Cert.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AuthCert: %s", err)
+	}
+	nTmp, err = s.Nonce.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Hello) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10676,7 +14228,9 @@ func (s Hello) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Hello) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10713,6 +14267,20 @@ func (s *Auth) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Auth)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Auth) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	s.Unused, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Auth) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10723,7 +14291,9 @@ func (s Auth) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Auth) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10780,6 +14350,21 @@ func (e IpAddrType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*IpAddrType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *IpAddrType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding IpAddrType: %s", err)
+	}
+	if _, ok := ipAddrTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid IpAddrType enum value", v)
+	}
+	*e = IpAddrType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s IpAddrType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10790,7 +14375,9 @@ func (s IpAddrType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *IpAddrType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10932,6 +14519,38 @@ func (u PeerAddressIp) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (IpAddrType) switch value '%d' is not valid for union PeerAddressIp", u.Type)
 }
 
+var _ decoderFrom = (*PeerAddressIp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *PeerAddressIp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding IpAddrType: %s", err)
+	}
+	switch IpAddrType(u.Type) {
+	case IpAddrTypeIPv4:
+		u.Ipv4 = new([4]byte)
+		nTmp, err = d.DecodeFixedOpaqueInplace((*u.Ipv4)[:])
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Ipv4: %s", err)
+		}
+		return n, nil
+	case IpAddrTypeIPv6:
+		u.Ipv6 = new([16]byte)
+		nTmp, err = d.DecodeFixedOpaqueInplace((*u.Ipv6)[:])
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Ipv6: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union PeerAddressIp has invalid Type (IpAddrType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PeerAddressIp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -10942,7 +14561,9 @@ func (s PeerAddressIp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PeerAddressIp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -10994,6 +14615,30 @@ func (s *PeerAddress) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PeerAddress)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PeerAddress) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Ip.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PeerAddressIp: %s", err)
+	}
+	nTmp, err = s.Port.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.NumFailures.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PeerAddress) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11004,7 +14649,9 @@ func (s PeerAddress) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PeerAddress) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11108,6 +14755,21 @@ func (e MessageType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*MessageType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *MessageType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding MessageType: %s", err)
+	}
+	if _, ok := messageTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid MessageType enum value", v)
+	}
+	*e = MessageType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s MessageType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11118,7 +14780,9 @@ func (s MessageType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *MessageType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11158,6 +14822,25 @@ func (s *DontHave) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*DontHave)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *DontHave) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MessageType: %s", err)
+	}
+	nTmp, err = s.ReqHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s DontHave) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11168,7 +14851,9 @@ func (s DontHave) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *DontHave) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11222,6 +14907,21 @@ func (e SurveyMessageCommandType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*SurveyMessageCommandType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *SurveyMessageCommandType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyMessageCommandType: %s", err)
+	}
+	if _, ok := surveyMessageCommandTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid SurveyMessageCommandType enum value", v)
+	}
+	*e = SurveyMessageCommandType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SurveyMessageCommandType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11232,7 +14932,9 @@ func (s SurveyMessageCommandType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SurveyMessageCommandType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11287,6 +14989,40 @@ func (s *SurveyRequestMessage) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SurveyRequestMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SurveyRequestMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SurveyorPeerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.SurveyedPeerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.LedgerNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.EncryptionKey.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Curve25519Public: %s", err)
+	}
+	nTmp, err = s.CommandType.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyMessageCommandType: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SurveyRequestMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11297,7 +15033,9 @@ func (s SurveyRequestMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SurveyRequestMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11337,6 +15075,25 @@ func (s *SignedSurveyRequestMessage) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SignedSurveyRequestMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SignedSurveyRequestMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.RequestSignature.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	nTmp, err = s.Request.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyRequestMessage: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SignedSurveyRequestMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11347,7 +15104,9 @@ func (s SignedSurveyRequestMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SignedSurveyRequestMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11382,6 +15141,20 @@ func (s EncryptedBody) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*EncryptedBody)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *EncryptedBody) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	(*s), nTmp, err = d.DecodeOpaque(64000)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EncryptedBody: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s EncryptedBody) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11392,7 +15165,9 @@ func (s EncryptedBody) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *EncryptedBody) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11447,6 +15222,40 @@ func (s *SurveyResponseMessage) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SurveyResponseMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SurveyResponseMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SurveyorPeerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.SurveyedPeerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	nTmp, err = s.LedgerNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.CommandType.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyMessageCommandType: %s", err)
+	}
+	nTmp, err = s.EncryptedBody.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EncryptedBody: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SurveyResponseMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11457,7 +15266,9 @@ func (s SurveyResponseMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SurveyResponseMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11497,6 +15308,25 @@ func (s *SignedSurveyResponseMessage) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SignedSurveyResponseMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SignedSurveyResponseMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.ResponseSignature.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	nTmp, err = s.Response.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyResponseMessage: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SignedSurveyResponseMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11507,7 +15337,9 @@ func (s SignedSurveyResponseMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SignedSurveyResponseMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11614,6 +15446,90 @@ func (s *PeerStats) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PeerStats)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PeerStats) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Id.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding NodeId: %s", err)
+	}
+	s.VersionStr, nTmp, err = d.DecodeString(100)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding VersionStr: %s", err)
+	}
+	nTmp, err = s.MessagesRead.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.MessagesWritten.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.BytesRead.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.BytesWritten.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.SecondsConnected.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.UniqueFloodBytesRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.DuplicateFloodBytesRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.UniqueFetchBytesRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.DuplicateFetchBytesRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.UniqueFloodMessageRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.DuplicateFloodMessageRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.UniqueFetchMessageRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.DuplicateFetchMessageRecv.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PeerStats) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11624,7 +15540,9 @@ func (s PeerStats) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PeerStats) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11664,6 +15582,35 @@ func (s PeerStatList) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PeerStatList)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PeerStatList) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PeerStats: %s", err)
+	}
+	if l > 25 {
+		return n, fmt.Errorf("decoding PeerStats: data size (%d) exceeds size limit (25)", l)
+	}
+	(*s) = nil
+	if l > 0 {
+		(*s) = make([]PeerStats, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = (*s)[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding PeerStats: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PeerStatList) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11674,7 +15621,9 @@ func (s PeerStatList) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PeerStatList) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11725,6 +15674,35 @@ func (s *TopologyResponseBody) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TopologyResponseBody)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TopologyResponseBody) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.InboundPeers.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PeerStatList: %s", err)
+	}
+	nTmp, err = s.OutboundPeers.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PeerStatList: %s", err)
+	}
+	nTmp, err = s.TotalInboundPeerCount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.TotalOutboundPeerCount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TopologyResponseBody) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11735,7 +15713,9 @@ func (s TopologyResponseBody) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TopologyResponseBody) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -11835,6 +15815,30 @@ func (u SurveyResponseBody) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (SurveyMessageCommandType) switch value '%d' is not valid for union SurveyResponseBody", u.Type)
 }
 
+var _ decoderFrom = (*SurveyResponseBody)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *SurveyResponseBody) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SurveyMessageCommandType: %s", err)
+	}
+	switch SurveyMessageCommandType(u.Type) {
+	case SurveyMessageCommandTypeSurveyTopology:
+		u.TopologyResponseBody = new(TopologyResponseBody)
+		nTmp, err = (*u.TopologyResponseBody).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TopologyResponseBody: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union SurveyResponseBody has invalid Type (SurveyMessageCommandType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SurveyResponseBody) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -11845,7 +15849,9 @@ func (s SurveyResponseBody) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SurveyResponseBody) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12511,6 +16517,152 @@ func (u StellarMessage) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (MessageType) switch value '%d' is not valid for union StellarMessage", u.Type)
 }
 
+var _ decoderFrom = (*StellarMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *StellarMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MessageType: %s", err)
+	}
+	switch MessageType(u.Type) {
+	case MessageTypeErrorMsg:
+		u.Error = new(Error)
+		nTmp, err = (*u.Error).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Error: %s", err)
+		}
+		return n, nil
+	case MessageTypeHello:
+		u.Hello = new(Hello)
+		nTmp, err = (*u.Hello).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Hello: %s", err)
+		}
+		return n, nil
+	case MessageTypeAuth:
+		u.Auth = new(Auth)
+		nTmp, err = (*u.Auth).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Auth: %s", err)
+		}
+		return n, nil
+	case MessageTypeDontHave:
+		u.DontHave = new(DontHave)
+		nTmp, err = (*u.DontHave).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding DontHave: %s", err)
+		}
+		return n, nil
+	case MessageTypeGetPeers:
+		// Void
+		return n, nil
+	case MessageTypePeers:
+		u.Peers = new([]PeerAddress)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PeerAddress: %s", err)
+		}
+		if l > 100 {
+			return n, fmt.Errorf("decoding PeerAddress: data size (%d) exceeds size limit (100)", l)
+		}
+		(*u.Peers) = nil
+		if l > 0 {
+			(*u.Peers) = make([]PeerAddress, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Peers)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding PeerAddress: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case MessageTypeGetTxSet:
+		u.TxSetHash = new(Uint256)
+		nTmp, err = (*u.TxSetHash).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	case MessageTypeTxSet:
+		u.TxSet = new(TransactionSet)
+		nTmp, err = (*u.TxSet).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionSet: %s", err)
+		}
+		return n, nil
+	case MessageTypeTransaction:
+		u.Transaction = new(TransactionEnvelope)
+		nTmp, err = (*u.Transaction).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionEnvelope: %s", err)
+		}
+		return n, nil
+	case MessageTypeSurveyRequest:
+		u.SignedSurveyRequestMessage = new(SignedSurveyRequestMessage)
+		nTmp, err = (*u.SignedSurveyRequestMessage).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SignedSurveyRequestMessage: %s", err)
+		}
+		return n, nil
+	case MessageTypeSurveyResponse:
+		u.SignedSurveyResponseMessage = new(SignedSurveyResponseMessage)
+		nTmp, err = (*u.SignedSurveyResponseMessage).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SignedSurveyResponseMessage: %s", err)
+		}
+		return n, nil
+	case MessageTypeGetScpQuorumset:
+		u.QSetHash = new(Uint256)
+		nTmp, err = (*u.QSetHash).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	case MessageTypeScpQuorumset:
+		u.QSet = new(ScpQuorumSet)
+		nTmp, err = (*u.QSet).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpQuorumSet: %s", err)
+		}
+		return n, nil
+	case MessageTypeScpMessage:
+		u.Envelope = new(ScpEnvelope)
+		nTmp, err = (*u.Envelope).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ScpEnvelope: %s", err)
+		}
+		return n, nil
+	case MessageTypeGetScpState:
+		u.GetScpLedgerSeq = new(Uint32)
+		nTmp, err = (*u.GetScpLedgerSeq).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union StellarMessage has invalid Type (MessageType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s StellarMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -12521,7 +16673,9 @@ func (s StellarMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *StellarMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12566,6 +16720,30 @@ func (s *AuthenticatedMessageV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AuthenticatedMessageV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AuthenticatedMessageV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Sequence.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.Message.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding StellarMessage: %s", err)
+	}
+	nTmp, err = s.Mac.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding HmacSha256Mac: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AuthenticatedMessageV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -12576,7 +16754,9 @@ func (s AuthenticatedMessageV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AuthenticatedMessageV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12681,6 +16861,30 @@ func (u AuthenticatedMessage) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (Uint32) switch value '%d' is not valid for union AuthenticatedMessage", u.V)
 }
 
+var _ decoderFrom = (*AuthenticatedMessage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AuthenticatedMessage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.V.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	switch Uint32(u.V) {
+	case 0:
+		u.V0 = new(AuthenticatedMessageV0)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AuthenticatedMessageV0: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union AuthenticatedMessage has invalid V (Uint32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AuthenticatedMessage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -12691,7 +16895,9 @@ func (s AuthenticatedMessage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AuthenticatedMessage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12791,6 +16997,30 @@ func (u LiquidityPoolParameters) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (LiquidityPoolType) switch value '%d' is not valid for union LiquidityPoolParameters", u.Type)
 }
 
+var _ decoderFrom = (*LiquidityPoolParameters)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LiquidityPoolParameters) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolType: %s", err)
+	}
+	switch LiquidityPoolType(u.Type) {
+	case LiquidityPoolTypeLiquidityPoolConstantProduct:
+		u.ConstantProduct = new(LiquidityPoolConstantProductParameters)
+		nTmp, err = (*u.ConstantProduct).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolConstantProductParameters: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union LiquidityPoolParameters has invalid Type (LiquidityPoolType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolParameters) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -12801,7 +17031,9 @@ func (s LiquidityPoolParameters) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolParameters) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12841,6 +17073,25 @@ func (s *MuxedAccountMed25519) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*MuxedAccountMed25519)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *MuxedAccountMed25519) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Id.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint64: %s", err)
+	}
+	nTmp, err = s.Ed25519.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s MuxedAccountMed25519) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -12851,7 +17102,9 @@ func (s MuxedAccountMed25519) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *MuxedAccountMed25519) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -12997,6 +17250,38 @@ func (u MuxedAccount) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (CryptoKeyType) switch value '%d' is not valid for union MuxedAccount", u.Type)
 }
 
+var _ decoderFrom = (*MuxedAccount)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *MuxedAccount) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding CryptoKeyType: %s", err)
+	}
+	switch CryptoKeyType(u.Type) {
+	case CryptoKeyTypeKeyTypeEd25519:
+		u.Ed25519 = new(Uint256)
+		nTmp, err = (*u.Ed25519).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	case CryptoKeyTypeKeyTypeMuxedEd25519:
+		u.Med25519 = new(MuxedAccountMed25519)
+		nTmp, err = (*u.Med25519).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding MuxedAccountMed25519: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union MuxedAccount has invalid Type (CryptoKeyType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s MuxedAccount) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13007,7 +17292,9 @@ func (s MuxedAccount) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *MuxedAccount) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13047,6 +17334,25 @@ func (s *DecoratedSignature) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*DecoratedSignature)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *DecoratedSignature) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Hint.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SignatureHint: %s", err)
+	}
+	nTmp, err = s.Signature.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s DecoratedSignature) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13057,7 +17363,9 @@ func (s DecoratedSignature) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *DecoratedSignature) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13180,6 +17488,21 @@ func (e OperationType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*OperationType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *OperationType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationType: %s", err)
+	}
+	if _, ok := operationTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid OperationType enum value", v)
+	}
+	*e = OperationType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13190,7 +17513,9 @@ func (s OperationType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13230,6 +17555,25 @@ func (s *CreateAccountOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*CreateAccountOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *CreateAccountOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.StartingBalance.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateAccountOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13240,7 +17584,9 @@ func (s CreateAccountOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateAccountOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13285,9 +17631,33 @@ func (s *PaymentOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
-func (s PaymentOp) MarshalBinary() ([]byte, error) {
-	b := bytes.Buffer{}
+var _ decoderFrom = (*PaymentOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PaymentOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
+func (s PaymentOp) MarshalBinary() ([]byte, error) {
+	b := bytes.Buffer{}
 	e := xdr.NewEncoder(&b)
 	err := s.EncodeTo(e)
 	return b.Bytes(), err
@@ -13295,7 +17665,9 @@ func (s PaymentOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PaymentOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13364,6 +17736,60 @@ func (s *PathPaymentStrictReceiveOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PathPaymentStrictReceiveOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PathPaymentStrictReceiveOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SendAsset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.SendMax.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.DestAsset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.DestAmount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	if l > 5 {
+		return n, fmt.Errorf("decoding Asset: data size (%d) exceeds size limit (5)", l)
+	}
+	s.Path = nil
+	if l > 0 {
+		s.Path = make([]Asset, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Path[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Asset: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictReceiveOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13374,7 +17800,9 @@ func (s PathPaymentStrictReceiveOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictReceiveOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13443,6 +17871,60 @@ func (s *PathPaymentStrictSendOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PathPaymentStrictSendOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PathPaymentStrictSendOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SendAsset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.SendAmount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.DestAsset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.DestMin.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	if l > 5 {
+		return n, fmt.Errorf("decoding Asset: data size (%d) exceeds size limit (5)", l)
+	}
+	s.Path = nil
+	if l > 0 {
+		s.Path = make([]Asset, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Path[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Asset: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictSendOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13453,7 +17935,9 @@ func (s PathPaymentStrictSendOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictSendOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13510,6 +17994,40 @@ func (s *ManageSellOfferOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ManageSellOfferOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ManageSellOfferOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Selling.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Buying.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Price.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageSellOfferOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13520,7 +18038,9 @@ func (s ManageSellOfferOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageSellOfferOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13578,6 +18098,40 @@ func (s *ManageBuyOfferOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ManageBuyOfferOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ManageBuyOfferOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Selling.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Buying.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.BuyAmount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Price.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageBuyOfferOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13588,7 +18142,9 @@ func (s ManageBuyOfferOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageBuyOfferOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13638,6 +18194,35 @@ func (s *CreatePassiveSellOfferOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*CreatePassiveSellOfferOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *CreatePassiveSellOfferOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Selling.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Buying.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Price.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreatePassiveSellOfferOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13648,7 +18233,9 @@ func (s CreatePassiveSellOfferOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreatePassiveSellOfferOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13775,6 +18362,142 @@ func (s *SetOptionsOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SetOptionsOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SetOptionsOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	s.InflationDest = nil
+	if b {
+		s.InflationDest = new(AccountId)
+		nTmp, err = s.InflationDest.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountId: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.ClearFlags = nil
+	if b {
+		s.ClearFlags = new(Uint32)
+		nTmp, err = s.ClearFlags.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.SetFlags = nil
+	if b {
+		s.SetFlags = new(Uint32)
+		nTmp, err = s.SetFlags.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.MasterWeight = nil
+	if b {
+		s.MasterWeight = new(Uint32)
+		nTmp, err = s.MasterWeight.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.LowThreshold = nil
+	if b {
+		s.LowThreshold = new(Uint32)
+		nTmp, err = s.LowThreshold.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.MedThreshold = nil
+	if b {
+		s.MedThreshold = new(Uint32)
+		nTmp, err = s.MedThreshold.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	s.HighThreshold = nil
+	if b {
+		s.HighThreshold = new(Uint32)
+		nTmp, err = s.HighThreshold.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String32: %s", err)
+	}
+	s.HomeDomain = nil
+	if b {
+		s.HomeDomain = new(String32)
+		nTmp, err = s.HomeDomain.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding String32: %s", err)
+		}
+	}
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signer: %s", err)
+	}
+	s.Signer = nil
+	if b {
+		s.Signer = new(Signer)
+		nTmp, err = s.Signer.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Signer: %s", err)
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetOptionsOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13785,7 +18508,9 @@ func (s SetOptionsOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetOptionsOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -13983,6 +18708,49 @@ func (u ChangeTrustAsset) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (AssetType) switch value '%d' is not valid for union ChangeTrustAsset", u.Type)
 }
 
+var _ decoderFrom = (*ChangeTrustAsset)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ChangeTrustAsset) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetType: %s", err)
+	}
+	switch AssetType(u.Type) {
+	case AssetTypeAssetTypeNative:
+		// Void
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum4:
+		u.AlphaNum4 = new(AlphaNum4)
+		nTmp, err = (*u.AlphaNum4).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum4: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypeCreditAlphanum12:
+		u.AlphaNum12 = new(AlphaNum12)
+		nTmp, err = (*u.AlphaNum12).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AlphaNum12: %s", err)
+		}
+		return n, nil
+	case AssetTypeAssetTypePoolShare:
+		u.LiquidityPool = new(LiquidityPoolParameters)
+		nTmp, err = (*u.LiquidityPool).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolParameters: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ChangeTrustAsset has invalid Type (AssetType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ChangeTrustAsset) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -13993,7 +18761,9 @@ func (s ChangeTrustAsset) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ChangeTrustAsset) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14035,6 +18805,25 @@ func (s *ChangeTrustOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ChangeTrustOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ChangeTrustOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Line.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ChangeTrustAsset: %s", err)
+	}
+	nTmp, err = s.Limit.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ChangeTrustOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14045,7 +18834,9 @@ func (s ChangeTrustOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ChangeTrustOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14092,6 +18883,30 @@ func (s *AllowTrustOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*AllowTrustOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *AllowTrustOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Trustor.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AssetCode: %s", err)
+	}
+	nTmp, err = s.Authorize.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AllowTrustOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14102,7 +18917,9 @@ func (s AllowTrustOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AllowTrustOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14147,6 +18964,35 @@ func (s *ManageDataOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ManageDataOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ManageDataOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.DataName.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding String64: %s", err)
+	}
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DataValue: %s", err)
+	}
+	s.DataValue = nil
+	if b {
+		s.DataValue = new(DataValue)
+		nTmp, err = s.DataValue.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding DataValue: %s", err)
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageDataOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14157,7 +19003,9 @@ func (s ManageDataOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageDataOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14192,6 +19040,20 @@ func (s *BumpSequenceOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*BumpSequenceOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *BumpSequenceOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.BumpTo.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BumpSequenceOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14202,7 +19064,9 @@ func (s BumpSequenceOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BumpSequenceOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14252,6 +19116,45 @@ func (s *CreateClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*CreateClaimableBalanceOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *CreateClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Claimant: %s", err)
+	}
+	if l > 10 {
+		return n, fmt.Errorf("decoding Claimant: data size (%d) exceeds size limit (10)", l)
+	}
+	s.Claimants = nil
+	if l > 0 {
+		s.Claimants = make([]Claimant, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Claimants[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Claimant: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14262,7 +19165,9 @@ func (s CreateClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateClaimableBalanceOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14297,6 +19202,20 @@ func (s *ClaimClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimClaimableBalanceOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.BalanceId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14307,7 +19226,9 @@ func (s ClaimClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimClaimableBalanceOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14342,6 +19263,20 @@ func (s *BeginSponsoringFutureReservesOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*BeginSponsoringFutureReservesOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *BeginSponsoringFutureReservesOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SponsoredId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BeginSponsoringFutureReservesOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14352,7 +19287,9 @@ func (s BeginSponsoringFutureReservesOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BeginSponsoringFutureReservesOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14409,6 +19346,21 @@ func (e RevokeSponsorshipType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*RevokeSponsorshipType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *RevokeSponsorshipType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding RevokeSponsorshipType: %s", err)
+	}
+	if _, ok := revokeSponsorshipTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid RevokeSponsorshipType enum value", v)
+	}
+	*e = RevokeSponsorshipType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s RevokeSponsorshipType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14419,7 +19371,9 @@ func (s RevokeSponsorshipType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *RevokeSponsorshipType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14459,6 +19413,25 @@ func (s *RevokeSponsorshipOpSigner) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*RevokeSponsorshipOpSigner)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *RevokeSponsorshipOpSigner) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.AccountId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.SignerKey.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SignerKey: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s RevokeSponsorshipOpSigner) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14469,7 +19442,9 @@ func (s RevokeSponsorshipOpSigner) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *RevokeSponsorshipOpSigner) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14615,6 +19590,38 @@ func (u RevokeSponsorshipOp) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (RevokeSponsorshipType) switch value '%d' is not valid for union RevokeSponsorshipOp", u.Type)
 }
 
+var _ decoderFrom = (*RevokeSponsorshipOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *RevokeSponsorshipOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding RevokeSponsorshipType: %s", err)
+	}
+	switch RevokeSponsorshipType(u.Type) {
+	case RevokeSponsorshipTypeRevokeSponsorshipLedgerEntry:
+		u.LedgerKey = new(LedgerKey)
+		nTmp, err = (*u.LedgerKey).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LedgerKey: %s", err)
+		}
+		return n, nil
+	case RevokeSponsorshipTypeRevokeSponsorshipSigner:
+		u.Signer = new(RevokeSponsorshipOpSigner)
+		nTmp, err = (*u.Signer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding RevokeSponsorshipOpSigner: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union RevokeSponsorshipOp has invalid Type (RevokeSponsorshipType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s RevokeSponsorshipOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14625,7 +19632,9 @@ func (s RevokeSponsorshipOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *RevokeSponsorshipOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14670,6 +19679,30 @@ func (s *ClawbackOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClawbackOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClawbackOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.From.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14680,7 +19713,9 @@ func (s ClawbackOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14715,6 +19750,20 @@ func (s *ClawbackClaimableBalanceOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClawbackClaimableBalanceOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClawbackClaimableBalanceOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.BalanceId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimableBalanceId: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14725,7 +19774,9 @@ func (s ClawbackClaimableBalanceOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackClaimableBalanceOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14776,6 +19827,35 @@ func (s *SetTrustLineFlagsOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SetTrustLineFlagsOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SetTrustLineFlagsOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Trustor.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.ClearFlags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.SetFlags.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetTrustLineFlagsOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14786,7 +19866,9 @@ func (s SetTrustLineFlagsOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetTrustLineFlagsOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14847,6 +19929,40 @@ func (s *LiquidityPoolDepositOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LiquidityPoolDepositOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LiquidityPoolDepositOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	nTmp, err = s.MaxAmountA.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.MaxAmountB.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.MinPrice.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	nTmp, err = s.MaxPrice.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Price: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolDepositOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14857,7 +19973,9 @@ func (s LiquidityPoolDepositOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolDepositOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -14907,6 +20025,35 @@ func (s *LiquidityPoolWithdrawOp) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*LiquidityPoolWithdrawOp)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *LiquidityPoolWithdrawOp) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.MinAmountA.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.MinAmountB.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolWithdrawOp) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -14917,7 +20064,9 @@ func (s LiquidityPoolWithdrawOp) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolWithdrawOp) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -15917,6 +21066,204 @@ func (u OperationBody) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (OperationType) switch value '%d' is not valid for union OperationBody", u.Type)
 }
 
+var _ decoderFrom = (*OperationBody)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *OperationBody) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationType: %s", err)
+	}
+	switch OperationType(u.Type) {
+	case OperationTypeCreateAccount:
+		u.CreateAccountOp = new(CreateAccountOp)
+		nTmp, err = (*u.CreateAccountOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding CreateAccountOp: %s", err)
+		}
+		return n, nil
+	case OperationTypePayment:
+		u.PaymentOp = new(PaymentOp)
+		nTmp, err = (*u.PaymentOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PaymentOp: %s", err)
+		}
+		return n, nil
+	case OperationTypePathPaymentStrictReceive:
+		u.PathPaymentStrictReceiveOp = new(PathPaymentStrictReceiveOp)
+		nTmp, err = (*u.PathPaymentStrictReceiveOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictReceiveOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeManageSellOffer:
+		u.ManageSellOfferOp = new(ManageSellOfferOp)
+		nTmp, err = (*u.ManageSellOfferOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageSellOfferOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeCreatePassiveSellOffer:
+		u.CreatePassiveSellOfferOp = new(CreatePassiveSellOfferOp)
+		nTmp, err = (*u.CreatePassiveSellOfferOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding CreatePassiveSellOfferOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeSetOptions:
+		u.SetOptionsOp = new(SetOptionsOp)
+		nTmp, err = (*u.SetOptionsOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SetOptionsOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeChangeTrust:
+		u.ChangeTrustOp = new(ChangeTrustOp)
+		nTmp, err = (*u.ChangeTrustOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ChangeTrustOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeAllowTrust:
+		u.AllowTrustOp = new(AllowTrustOp)
+		nTmp, err = (*u.AllowTrustOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AllowTrustOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeAccountMerge:
+		u.Destination = new(MuxedAccount)
+		nTmp, err = (*u.Destination).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+		}
+		return n, nil
+	case OperationTypeInflation:
+		// Void
+		return n, nil
+	case OperationTypeManageData:
+		u.ManageDataOp = new(ManageDataOp)
+		nTmp, err = (*u.ManageDataOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageDataOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeBumpSequence:
+		u.BumpSequenceOp = new(BumpSequenceOp)
+		nTmp, err = (*u.BumpSequenceOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding BumpSequenceOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeManageBuyOffer:
+		u.ManageBuyOfferOp = new(ManageBuyOfferOp)
+		nTmp, err = (*u.ManageBuyOfferOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageBuyOfferOp: %s", err)
+		}
+		return n, nil
+	case OperationTypePathPaymentStrictSend:
+		u.PathPaymentStrictSendOp = new(PathPaymentStrictSendOp)
+		nTmp, err = (*u.PathPaymentStrictSendOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictSendOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeCreateClaimableBalance:
+		u.CreateClaimableBalanceOp = new(CreateClaimableBalanceOp)
+		nTmp, err = (*u.CreateClaimableBalanceOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding CreateClaimableBalanceOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeClaimClaimableBalance:
+		u.ClaimClaimableBalanceOp = new(ClaimClaimableBalanceOp)
+		nTmp, err = (*u.ClaimClaimableBalanceOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimClaimableBalanceOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeBeginSponsoringFutureReserves:
+		u.BeginSponsoringFutureReservesOp = new(BeginSponsoringFutureReservesOp)
+		nTmp, err = (*u.BeginSponsoringFutureReservesOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding BeginSponsoringFutureReservesOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeEndSponsoringFutureReserves:
+		// Void
+		return n, nil
+	case OperationTypeRevokeSponsorship:
+		u.RevokeSponsorshipOp = new(RevokeSponsorshipOp)
+		nTmp, err = (*u.RevokeSponsorshipOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding RevokeSponsorshipOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeClawback:
+		u.ClawbackOp = new(ClawbackOp)
+		nTmp, err = (*u.ClawbackOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClawbackOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeClawbackClaimableBalance:
+		u.ClawbackClaimableBalanceOp = new(ClawbackClaimableBalanceOp)
+		nTmp, err = (*u.ClawbackClaimableBalanceOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClawbackClaimableBalanceOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeSetTrustLineFlags:
+		u.SetTrustLineFlagsOp = new(SetTrustLineFlagsOp)
+		nTmp, err = (*u.SetTrustLineFlagsOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SetTrustLineFlagsOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeLiquidityPoolDeposit:
+		u.LiquidityPoolDepositOp = new(LiquidityPoolDepositOp)
+		nTmp, err = (*u.LiquidityPoolDepositOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolDepositOp: %s", err)
+		}
+		return n, nil
+	case OperationTypeLiquidityPoolWithdraw:
+		u.LiquidityPoolWithdrawOp = new(LiquidityPoolWithdrawOp)
+		nTmp, err = (*u.LiquidityPoolWithdrawOp).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolWithdrawOp: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union OperationBody has invalid Type (OperationType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationBody) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -15927,7 +21274,9 @@ func (s OperationBody) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationBody) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16027,6 +21376,35 @@ func (s *Operation) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Operation)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Operation) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	s.SourceAccount = nil
+	if b {
+		s.SourceAccount = new(MuxedAccount)
+		nTmp, err = s.SourceAccount.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+		}
+	}
+	nTmp, err = s.Body.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationBody: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Operation) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16037,7 +21415,9 @@ func (s Operation) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Operation) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16082,6 +21462,30 @@ func (s *HashIdPreimageOperationId) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*HashIdPreimageOperationId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *HashIdPreimageOperationId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SourceAccount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.SeqNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	nTmp, err = s.OpNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s HashIdPreimageOperationId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16092,7 +21496,9 @@ func (s HashIdPreimageOperationId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *HashIdPreimageOperationId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16147,6 +21553,40 @@ func (s *HashIdPreimageRevokeId) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*HashIdPreimageRevokeId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *HashIdPreimageRevokeId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SourceAccount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.SeqNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	nTmp, err = s.OpNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s HashIdPreimageRevokeId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16157,7 +21597,9 @@ func (s HashIdPreimageRevokeId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *HashIdPreimageRevokeId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16311,6 +21753,38 @@ func (u HashIdPreimage) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (EnvelopeType) switch value '%d' is not valid for union HashIdPreimage", u.Type)
 }
 
+var _ decoderFrom = (*HashIdPreimage)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *HashIdPreimage) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EnvelopeType: %s", err)
+	}
+	switch EnvelopeType(u.Type) {
+	case EnvelopeTypeEnvelopeTypeOpId:
+		u.OperationId = new(HashIdPreimageOperationId)
+		nTmp, err = (*u.OperationId).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding HashIdPreimageOperationId: %s", err)
+		}
+		return n, nil
+	case EnvelopeTypeEnvelopeTypePoolRevokeOpId:
+		u.RevokeId = new(HashIdPreimageRevokeId)
+		nTmp, err = (*u.RevokeId).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding HashIdPreimageRevokeId: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union HashIdPreimage has invalid Type (EnvelopeType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s HashIdPreimage) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16321,7 +21795,9 @@ func (s HashIdPreimage) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *HashIdPreimage) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16387,6 +21863,21 @@ func (e MemoType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*MemoType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *MemoType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding MemoType: %s", err)
+	}
+	if _, ok := memoTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid MemoType enum value", v)
+	}
+	*e = MemoType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s MemoType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16397,7 +21888,9 @@ func (s MemoType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *MemoType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16632,6 +22125,57 @@ func (u Memo) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (MemoType) switch value '%d' is not valid for union Memo", u.Type)
 }
 
+var _ decoderFrom = (*Memo)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *Memo) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MemoType: %s", err)
+	}
+	switch MemoType(u.Type) {
+	case MemoTypeMemoNone:
+		// Void
+		return n, nil
+	case MemoTypeMemoText:
+		u.Text = new(string)
+		(*u.Text), nTmp, err = d.DecodeString(28)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Text: %s", err)
+		}
+		return n, nil
+	case MemoTypeMemoId:
+		u.Id = new(Uint64)
+		nTmp, err = (*u.Id).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint64: %s", err)
+		}
+		return n, nil
+	case MemoTypeMemoHash:
+		u.Hash = new(Hash)
+		nTmp, err = (*u.Hash).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Hash: %s", err)
+		}
+		return n, nil
+	case MemoTypeMemoReturn:
+		u.RetHash = new(Hash)
+		nTmp, err = (*u.RetHash).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Hash: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union Memo has invalid Type (MemoType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Memo) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16642,7 +22186,9 @@ func (s Memo) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Memo) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16682,6 +22228,25 @@ func (s *TimeBounds) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TimeBounds)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TimeBounds) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.MinTime.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TimePoint: %s", err)
+	}
+	nTmp, err = s.MaxTime.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TimePoint: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TimeBounds) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16692,7 +22257,9 @@ func (s TimeBounds) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TimeBounds) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16765,6 +22332,25 @@ func (u TransactionV0Ext) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionV0Ext", u.V)
 }
 
+var _ decoderFrom = (*TransactionV0Ext)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionV0Ext) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionV0Ext has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionV0Ext) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16775,7 +22361,9 @@ func (s TransactionV0Ext) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionV0Ext) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16855,6 +22443,75 @@ func (s *TransactionV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SourceAccountEd25519.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	nTmp, err = s.Fee.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.SeqNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TimeBounds: %s", err)
+	}
+	s.TimeBounds = nil
+	if b {
+		s.TimeBounds = new(TimeBounds)
+		nTmp, err = s.TimeBounds.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TimeBounds: %s", err)
+		}
+	}
+	nTmp, err = s.Memo.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Memo: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Operation: %s", err)
+	}
+	if l > 100 {
+		return n, fmt.Errorf("decoding Operation: data size (%d) exceeds size limit (100)", l)
+	}
+	s.Operations = nil
+	if l > 0 {
+		s.Operations = make([]Operation, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Operations[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Operation: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionV0Ext: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16865,7 +22522,9 @@ func (s TransactionV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16912,6 +22571,40 @@ func (s *TransactionV0Envelope) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionV0Envelope)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionV0Envelope) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Tx.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionV0: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+	}
+	if l > 20 {
+		return n, fmt.Errorf("decoding DecoratedSignature: data size (%d) exceeds size limit (20)", l)
+	}
+	s.Signatures = nil
+	if l > 0 {
+		s.Signatures = make([]DecoratedSignature, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Signatures[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionV0Envelope) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16922,7 +22615,9 @@ func (s TransactionV0Envelope) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionV0Envelope) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -16989,6 +22684,25 @@ func (u TransactionExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionExt", u.V)
 }
 
+var _ decoderFrom = (*TransactionExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -16999,7 +22713,9 @@ func (s TransactionExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17090,6 +22806,75 @@ func (s *Transaction) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Transaction)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Transaction) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SourceAccount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.Fee.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint32: %s", err)
+	}
+	nTmp, err = s.SeqNum.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SequenceNumber: %s", err)
+	}
+	var b bool
+	b, nTmp, err = d.DecodeBool()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TimeBounds: %s", err)
+	}
+	s.TimeBounds = nil
+	if b {
+		s.TimeBounds = new(TimeBounds)
+		nTmp, err = s.TimeBounds.DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TimeBounds: %s", err)
+		}
+	}
+	nTmp, err = s.Memo.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Memo: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Operation: %s", err)
+	}
+	if l > 100 {
+		return n, fmt.Errorf("decoding Operation: data size (%d) exceeds size limit (100)", l)
+	}
+	s.Operations = nil
+	if l > 0 {
+		s.Operations = make([]Operation, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Operations[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding Operation: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Transaction) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17100,7 +22885,9 @@ func (s Transaction) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Transaction) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17147,6 +22934,40 @@ func (s *TransactionV1Envelope) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionV1Envelope)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionV1Envelope) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Tx.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Transaction: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+	}
+	if l > 20 {
+		return n, fmt.Errorf("decoding DecoratedSignature: data size (%d) exceeds size limit (20)", l)
+	}
+	s.Signatures = nil
+	if l > 0 {
+		s.Signatures = make([]DecoratedSignature, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Signatures[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionV1Envelope) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17157,7 +22978,9 @@ func (s TransactionV1Envelope) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionV1Envelope) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17257,6 +23080,30 @@ func (u FeeBumpTransactionInnerTx) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (EnvelopeType) switch value '%d' is not valid for union FeeBumpTransactionInnerTx", u.Type)
 }
 
+var _ decoderFrom = (*FeeBumpTransactionInnerTx)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *FeeBumpTransactionInnerTx) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EnvelopeType: %s", err)
+	}
+	switch EnvelopeType(u.Type) {
+	case EnvelopeTypeEnvelopeTypeTx:
+		u.V1 = new(TransactionV1Envelope)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionV1Envelope: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union FeeBumpTransactionInnerTx has invalid Type (EnvelopeType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s FeeBumpTransactionInnerTx) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17267,7 +23114,9 @@ func (s FeeBumpTransactionInnerTx) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *FeeBumpTransactionInnerTx) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17334,6 +23183,25 @@ func (u FeeBumpTransactionExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union FeeBumpTransactionExt", u.V)
 }
 
+var _ decoderFrom = (*FeeBumpTransactionExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *FeeBumpTransactionExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union FeeBumpTransactionExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s FeeBumpTransactionExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17344,7 +23212,9 @@ func (s FeeBumpTransactionExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *FeeBumpTransactionExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17404,6 +23274,35 @@ func (s *FeeBumpTransaction) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*FeeBumpTransaction)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *FeeBumpTransaction) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.FeeSource.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding MuxedAccount: %s", err)
+	}
+	nTmp, err = s.Fee.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.InnerTx.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding FeeBumpTransactionInnerTx: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding FeeBumpTransactionExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s FeeBumpTransaction) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17414,7 +23313,9 @@ func (s FeeBumpTransaction) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *FeeBumpTransaction) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17461,6 +23362,40 @@ func (s *FeeBumpTransactionEnvelope) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*FeeBumpTransactionEnvelope)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *FeeBumpTransactionEnvelope) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Tx.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding FeeBumpTransaction: %s", err)
+	}
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+	}
+	if l > 20 {
+		return n, fmt.Errorf("decoding DecoratedSignature: data size (%d) exceeds size limit (20)", l)
+	}
+	s.Signatures = nil
+	if l > 0 {
+		s.Signatures = make([]DecoratedSignature, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Signatures[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding DecoratedSignature: %s", err)
+			}
+		}
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s FeeBumpTransactionEnvelope) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17471,7 +23406,9 @@ func (s FeeBumpTransactionEnvelope) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *FeeBumpTransactionEnvelope) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17655,6 +23592,46 @@ func (u TransactionEnvelope) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (EnvelopeType) switch value '%d' is not valid for union TransactionEnvelope", u.Type)
 }
 
+var _ decoderFrom = (*TransactionEnvelope)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionEnvelope) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EnvelopeType: %s", err)
+	}
+	switch EnvelopeType(u.Type) {
+	case EnvelopeTypeEnvelopeTypeTxV0:
+		u.V0 = new(TransactionV0Envelope)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionV0Envelope: %s", err)
+		}
+		return n, nil
+	case EnvelopeTypeEnvelopeTypeTx:
+		u.V1 = new(TransactionV1Envelope)
+		nTmp, err = (*u.V1).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding TransactionV1Envelope: %s", err)
+		}
+		return n, nil
+	case EnvelopeTypeEnvelopeTypeTxFeeBump:
+		u.FeeBump = new(FeeBumpTransactionEnvelope)
+		nTmp, err = (*u.FeeBump).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding FeeBumpTransactionEnvelope: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionEnvelope has invalid Type (EnvelopeType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionEnvelope) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17665,7 +23642,9 @@ func (s TransactionEnvelope) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionEnvelope) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17808,6 +23787,38 @@ func (u TransactionSignaturePayloadTaggedTransaction) EncodeTo(e *xdr.Encoder) e
 	return fmt.Errorf("Type (EnvelopeType) switch value '%d' is not valid for union TransactionSignaturePayloadTaggedTransaction", u.Type)
 }
 
+var _ decoderFrom = (*TransactionSignaturePayloadTaggedTransaction)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionSignaturePayloadTaggedTransaction) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EnvelopeType: %s", err)
+	}
+	switch EnvelopeType(u.Type) {
+	case EnvelopeTypeEnvelopeTypeTx:
+		u.Tx = new(Transaction)
+		nTmp, err = (*u.Tx).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Transaction: %s", err)
+		}
+		return n, nil
+	case EnvelopeTypeEnvelopeTypeTxFeeBump:
+		u.FeeBump = new(FeeBumpTransaction)
+		nTmp, err = (*u.FeeBump).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding FeeBumpTransaction: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionSignaturePayloadTaggedTransaction has invalid Type (EnvelopeType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionSignaturePayloadTaggedTransaction) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17818,7 +23829,9 @@ func (s TransactionSignaturePayloadTaggedTransaction) MarshalBinary() ([]byte, e
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionSignaturePayloadTaggedTransaction) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17866,6 +23879,25 @@ func (s *TransactionSignaturePayload) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionSignaturePayload)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionSignaturePayload) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.NetworkId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.TaggedTransaction.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionSignaturePayloadTaggedTransaction: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionSignaturePayload) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17876,7 +23908,9 @@ func (s TransactionSignaturePayload) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionSignaturePayload) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -17936,6 +23970,21 @@ func (e ClaimAtomType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimAtomType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimAtomType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimAtomType: %s", err)
+	}
+	if _, ok := claimAtomTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimAtomType enum value", v)
+	}
+	*e = ClaimAtomType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimAtomType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -17946,7 +23995,9 @@ func (s ClaimAtomType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimAtomType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18011,6 +24062,45 @@ func (s *ClaimOfferAtomV0) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimOfferAtomV0)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimOfferAtomV0) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SellerEd25519.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.AssetSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.AssetBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimOfferAtomV0) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18021,7 +24111,9 @@ func (s ClaimOfferAtomV0) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimOfferAtomV0) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18086,6 +24178,45 @@ func (s *ClaimOfferAtom) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimOfferAtom)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimOfferAtom) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.SellerId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.OfferId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.AssetSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.AssetBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimOfferAtom) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18096,7 +24227,9 @@ func (s ClaimOfferAtom) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimOfferAtom) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18155,6 +24288,40 @@ func (s *ClaimLiquidityAtom) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ClaimLiquidityAtom)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ClaimLiquidityAtom) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.LiquidityPoolId.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PoolId: %s", err)
+	}
+	nTmp, err = s.AssetSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountSold.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.AssetBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.AmountBought.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimLiquidityAtom) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18165,7 +24332,9 @@ func (s ClaimLiquidityAtom) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimLiquidityAtom) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18349,6 +24518,46 @@ func (u ClaimAtom) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (ClaimAtomType) switch value '%d' is not valid for union ClaimAtom", u.Type)
 }
 
+var _ decoderFrom = (*ClaimAtom)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimAtom) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimAtomType: %s", err)
+	}
+	switch ClaimAtomType(u.Type) {
+	case ClaimAtomTypeClaimAtomTypeV0:
+		u.V0 = new(ClaimOfferAtomV0)
+		nTmp, err = (*u.V0).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimOfferAtomV0: %s", err)
+		}
+		return n, nil
+	case ClaimAtomTypeClaimAtomTypeOrderBook:
+		u.OrderBook = new(ClaimOfferAtom)
+		nTmp, err = (*u.OrderBook).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimOfferAtom: %s", err)
+		}
+		return n, nil
+	case ClaimAtomTypeClaimAtomTypeLiquidityPool:
+		u.LiquidityPool = new(ClaimLiquidityAtom)
+		nTmp, err = (*u.LiquidityPool).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimLiquidityAtom: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union ClaimAtom has invalid Type (ClaimAtomType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimAtom) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18359,7 +24568,9 @@ func (s ClaimAtom) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimAtom) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18429,6 +24640,21 @@ func (e CreateAccountResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*CreateAccountResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *CreateAccountResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding CreateAccountResultCode: %s", err)
+	}
+	if _, ok := createAccountResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid CreateAccountResultCode enum value", v)
+	}
+	*e = CreateAccountResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateAccountResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18439,7 +24665,9 @@ func (s CreateAccountResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateAccountResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18513,6 +24741,27 @@ func (u CreateAccountResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*CreateAccountResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *CreateAccountResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding CreateAccountResultCode: %s", err)
+	}
+	switch CreateAccountResultCode(u.Code) {
+	case CreateAccountResultCodeCreateAccountSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateAccountResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18523,7 +24772,9 @@ func (s CreateAccountResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateAccountResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18607,6 +24858,21 @@ func (e PaymentResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*PaymentResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *PaymentResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding PaymentResultCode: %s", err)
+	}
+	if _, ok := paymentResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid PaymentResultCode enum value", v)
+	}
+	*e = PaymentResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PaymentResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18617,7 +24883,9 @@ func (s PaymentResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PaymentResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18691,6 +24959,27 @@ func (u PaymentResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*PaymentResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *PaymentResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PaymentResultCode: %s", err)
+	}
+	switch PaymentResultCode(u.Code) {
+	case PaymentResultCodePaymentSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PaymentResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18701,7 +24990,9 @@ func (s PaymentResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PaymentResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18803,6 +25094,21 @@ func (e PathPaymentStrictReceiveResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*PathPaymentStrictReceiveResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *PathPaymentStrictReceiveResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding PathPaymentStrictReceiveResultCode: %s", err)
+	}
+	if _, ok := pathPaymentStrictReceiveResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid PathPaymentStrictReceiveResultCode enum value", v)
+	}
+	*e = PathPaymentStrictReceiveResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictReceiveResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18813,7 +25119,9 @@ func (s PathPaymentStrictReceiveResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictReceiveResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18858,6 +25166,30 @@ func (s *SimplePaymentResult) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SimplePaymentResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SimplePaymentResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Asset.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Asset: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SimplePaymentResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18868,7 +25200,9 @@ func (s SimplePaymentResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SimplePaymentResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -18913,6 +25247,37 @@ func (s *PathPaymentStrictReceiveResultSuccess) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PathPaymentStrictReceiveResultSuccess)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PathPaymentStrictReceiveResultSuccess) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+	}
+	s.Offers = nil
+	if l > 0 {
+		s.Offers = make([]ClaimAtom, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Offers[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Last.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SimplePaymentResult: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictReceiveResultSuccess) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -18923,7 +25288,9 @@ func (s PathPaymentStrictReceiveResultSuccess) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictReceiveResultSuccess) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19077,7 +25444,41 @@ func (u PathPaymentStrictReceiveResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
-// MarshalBinary implements encoding.BinaryMarshaler.
+var _ decoderFrom = (*PathPaymentStrictReceiveResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *PathPaymentStrictReceiveResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PathPaymentStrictReceiveResultCode: %s", err)
+	}
+	switch PathPaymentStrictReceiveResultCode(u.Code) {
+	case PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveSuccess:
+		u.Success = new(PathPaymentStrictReceiveResultSuccess)
+		nTmp, err = (*u.Success).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictReceiveResultSuccess: %s", err)
+		}
+		return n, nil
+	case PathPaymentStrictReceiveResultCodePathPaymentStrictReceiveNoIssuer:
+		u.NoIssuer = new(Asset)
+		nTmp, err = (*u.NoIssuer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Asset: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
+// MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictReceiveResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
 	e := xdr.NewEncoder(&b)
@@ -19087,7 +25488,9 @@ func (s PathPaymentStrictReceiveResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictReceiveResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19188,6 +25591,21 @@ func (e PathPaymentStrictSendResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*PathPaymentStrictSendResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *PathPaymentStrictSendResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding PathPaymentStrictSendResultCode: %s", err)
+	}
+	if _, ok := pathPaymentStrictSendResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid PathPaymentStrictSendResultCode enum value", v)
+	}
+	*e = PathPaymentStrictSendResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictSendResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19198,7 +25616,9 @@ func (s PathPaymentStrictSendResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictSendResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19243,6 +25663,37 @@ func (s *PathPaymentStrictSendResultSuccess) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*PathPaymentStrictSendResultSuccess)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *PathPaymentStrictSendResultSuccess) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+	}
+	s.Offers = nil
+	if l > 0 {
+		s.Offers = make([]ClaimAtom, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.Offers[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Last.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SimplePaymentResult: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictSendResultSuccess) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19253,7 +25704,9 @@ func (s PathPaymentStrictSendResultSuccess) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictSendResultSuccess) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19406,6 +25859,40 @@ func (u PathPaymentStrictSendResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*PathPaymentStrictSendResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *PathPaymentStrictSendResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PathPaymentStrictSendResultCode: %s", err)
+	}
+	switch PathPaymentStrictSendResultCode(u.Code) {
+	case PathPaymentStrictSendResultCodePathPaymentStrictSendSuccess:
+		u.Success = new(PathPaymentStrictSendResultSuccess)
+		nTmp, err = (*u.Success).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictSendResultSuccess: %s", err)
+		}
+		return n, nil
+	case PathPaymentStrictSendResultCodePathPaymentStrictSendNoIssuer:
+		u.NoIssuer = new(Asset)
+		nTmp, err = (*u.NoIssuer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Asset: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PathPaymentStrictSendResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19416,7 +25903,9 @@ func (s PathPaymentStrictSendResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PathPaymentStrictSendResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19516,6 +26005,21 @@ func (e ManageSellOfferResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ManageSellOfferResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ManageSellOfferResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageSellOfferResultCode: %s", err)
+	}
+	if _, ok := manageSellOfferResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ManageSellOfferResultCode enum value", v)
+	}
+	*e = ManageSellOfferResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageSellOfferResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19526,7 +26030,9 @@ func (s ManageSellOfferResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageSellOfferResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19586,6 +26092,21 @@ func (e ManageOfferEffect) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ManageOfferEffect)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ManageOfferEffect) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageOfferEffect: %s", err)
+	}
+	if _, ok := manageOfferEffectMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ManageOfferEffect enum value", v)
+	}
+	*e = ManageOfferEffect(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageOfferEffect) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19596,7 +26117,9 @@ func (s ManageOfferEffect) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageOfferEffect) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19718,6 +26241,40 @@ func (u ManageOfferSuccessResultOffer) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ManageOfferSuccessResultOffer)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ManageOfferSuccessResultOffer) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Effect.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageOfferEffect: %s", err)
+	}
+	switch ManageOfferEffect(u.Effect) {
+	case ManageOfferEffectManageOfferCreated:
+		u.Offer = new(OfferEntry)
+		nTmp, err = (*u.Offer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OfferEntry: %s", err)
+		}
+		return n, nil
+	case ManageOfferEffectManageOfferUpdated:
+		u.Offer = new(OfferEntry)
+		nTmp, err = (*u.Offer).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OfferEntry: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageOfferSuccessResultOffer) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19728,7 +26285,9 @@ func (s ManageOfferSuccessResultOffer) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageOfferSuccessResultOffer) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19783,6 +26342,37 @@ func (s *ManageOfferSuccessResult) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*ManageOfferSuccessResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *ManageOfferSuccessResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var l uint32
+	l, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+	}
+	s.OffersClaimed = nil
+	if l > 0 {
+		s.OffersClaimed = make([]ClaimAtom, l)
+		for i := uint32(0); i < l; i++ {
+			nTmp, err = s.OffersClaimed[i].DecodeFrom(d)
+			n += nTmp
+			if err != nil {
+				return n, fmt.Errorf("decoding ClaimAtom: %s", err)
+			}
+		}
+	}
+	nTmp, err = s.Offer.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageOfferSuccessResultOffer: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageOfferSuccessResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19793,7 +26383,9 @@ func (s ManageOfferSuccessResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageOfferSuccessResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -19900,6 +26492,32 @@ func (u ManageSellOfferResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ManageSellOfferResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ManageSellOfferResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageSellOfferResultCode: %s", err)
+	}
+	switch ManageSellOfferResultCode(u.Code) {
+	case ManageSellOfferResultCodeManageSellOfferSuccess:
+		u.Success = new(ManageOfferSuccessResult)
+		nTmp, err = (*u.Success).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageOfferSuccessResult: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageSellOfferResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -19910,7 +26528,9 @@ func (s ManageSellOfferResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageSellOfferResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20007,6 +26627,21 @@ func (e ManageBuyOfferResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ManageBuyOfferResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ManageBuyOfferResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageBuyOfferResultCode: %s", err)
+	}
+	if _, ok := manageBuyOfferResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ManageBuyOfferResultCode enum value", v)
+	}
+	*e = ManageBuyOfferResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageBuyOfferResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20017,7 +26652,9 @@ func (s ManageBuyOfferResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageBuyOfferResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20124,6 +26761,32 @@ func (u ManageBuyOfferResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ManageBuyOfferResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ManageBuyOfferResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageBuyOfferResultCode: %s", err)
+	}
+	switch ManageBuyOfferResultCode(u.Code) {
+	case ManageBuyOfferResultCodeManageBuyOfferSuccess:
+		u.Success = new(ManageOfferSuccessResult)
+		nTmp, err = (*u.Success).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageOfferSuccessResult: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageBuyOfferResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20134,7 +26797,9 @@ func (s ManageBuyOfferResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageBuyOfferResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20221,6 +26886,21 @@ func (e SetOptionsResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*SetOptionsResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *SetOptionsResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding SetOptionsResultCode: %s", err)
+	}
+	if _, ok := setOptionsResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid SetOptionsResultCode enum value", v)
+	}
+	*e = SetOptionsResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetOptionsResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20231,7 +26911,9 @@ func (s SetOptionsResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetOptionsResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20305,6 +26987,27 @@ func (u SetOptionsResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*SetOptionsResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *SetOptionsResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SetOptionsResultCode: %s", err)
+	}
+	switch SetOptionsResultCode(u.Code) {
+	case SetOptionsResultCodeSetOptionsSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetOptionsResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20315,7 +27018,9 @@ func (s SetOptionsResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetOptionsResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20397,6 +27102,21 @@ func (e ChangeTrustResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ChangeTrustResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ChangeTrustResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ChangeTrustResultCode: %s", err)
+	}
+	if _, ok := changeTrustResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ChangeTrustResultCode enum value", v)
+	}
+	*e = ChangeTrustResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ChangeTrustResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20407,7 +27127,9 @@ func (s ChangeTrustResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ChangeTrustResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20481,6 +27203,27 @@ func (u ChangeTrustResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ChangeTrustResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ChangeTrustResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ChangeTrustResultCode: %s", err)
+	}
+	switch ChangeTrustResultCode(u.Code) {
+	case ChangeTrustResultCodeChangeTrustSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ChangeTrustResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20491,7 +27234,9 @@ func (s ChangeTrustResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ChangeTrustResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20567,6 +27312,21 @@ func (e AllowTrustResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*AllowTrustResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *AllowTrustResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding AllowTrustResultCode: %s", err)
+	}
+	if _, ok := allowTrustResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid AllowTrustResultCode enum value", v)
+	}
+	*e = AllowTrustResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AllowTrustResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20577,7 +27337,9 @@ func (s AllowTrustResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AllowTrustResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20651,6 +27413,27 @@ func (u AllowTrustResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*AllowTrustResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AllowTrustResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AllowTrustResultCode: %s", err)
+	}
+	switch AllowTrustResultCode(u.Code) {
+	case AllowTrustResultCodeAllowTrustSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AllowTrustResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20661,7 +27444,9 @@ func (s AllowTrustResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AllowTrustResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20739,6 +27524,21 @@ func (e AccountMergeResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*AccountMergeResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *AccountMergeResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountMergeResultCode: %s", err)
+	}
+	if _, ok := accountMergeResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid AccountMergeResultCode enum value", v)
+	}
+	*e = AccountMergeResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountMergeResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20749,7 +27549,9 @@ func (s AccountMergeResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountMergeResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20856,6 +27658,32 @@ func (u AccountMergeResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*AccountMergeResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *AccountMergeResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountMergeResultCode: %s", err)
+	}
+	switch AccountMergeResultCode(u.Code) {
+	case AccountMergeResultCodeAccountMergeSuccess:
+		u.SourceAccountBalance = new(Int64)
+		nTmp, err = (*u.SourceAccountBalance).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Int64: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s AccountMergeResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20866,7 +27694,9 @@ func (s AccountMergeResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *AccountMergeResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20925,6 +27755,21 @@ func (e InflationResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*InflationResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *InflationResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding InflationResultCode: %s", err)
+	}
+	if _, ok := inflationResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid InflationResultCode enum value", v)
+	}
+	*e = InflationResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InflationResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20935,7 +27780,9 @@ func (s InflationResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InflationResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -20975,6 +27822,25 @@ func (s *InflationPayout) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*InflationPayout)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *InflationPayout) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.Destination.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding AccountId: %s", err)
+	}
+	nTmp, err = s.Amount.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InflationPayout) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -20985,7 +27851,9 @@ func (s InflationPayout) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InflationPayout) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21097,6 +27965,44 @@ func (u InflationResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*InflationResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *InflationResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding InflationResultCode: %s", err)
+	}
+	switch InflationResultCode(u.Code) {
+	case InflationResultCodeInflationSuccess:
+		u.Payouts = new([]InflationPayout)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding InflationPayout: %s", err)
+		}
+		(*u.Payouts) = nil
+		if l > 0 {
+			(*u.Payouts) = make([]InflationPayout, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Payouts)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding InflationPayout: %s", err)
+				}
+			}
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InflationResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21107,7 +28013,9 @@ func (s InflationResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InflationResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21177,6 +28085,21 @@ func (e ManageDataResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ManageDataResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ManageDataResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageDataResultCode: %s", err)
+	}
+	if _, ok := manageDataResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ManageDataResultCode enum value", v)
+	}
+	*e = ManageDataResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageDataResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21187,7 +28110,9 @@ func (s ManageDataResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageDataResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21261,6 +28186,27 @@ func (u ManageDataResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ManageDataResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ManageDataResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ManageDataResultCode: %s", err)
+	}
+	switch ManageDataResultCode(u.Code) {
+	case ManageDataResultCodeManageDataSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ManageDataResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21271,7 +28217,9 @@ func (s ManageDataResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ManageDataResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21330,6 +28278,21 @@ func (e BumpSequenceResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*BumpSequenceResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *BumpSequenceResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding BumpSequenceResultCode: %s", err)
+	}
+	if _, ok := bumpSequenceResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid BumpSequenceResultCode enum value", v)
+	}
+	*e = BumpSequenceResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BumpSequenceResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21340,7 +28303,9 @@ func (s BumpSequenceResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BumpSequenceResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21414,6 +28379,27 @@ func (u BumpSequenceResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*BumpSequenceResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *BumpSequenceResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding BumpSequenceResultCode: %s", err)
+	}
+	switch BumpSequenceResultCode(u.Code) {
+	case BumpSequenceResultCodeBumpSequenceSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BumpSequenceResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21424,7 +28410,9 @@ func (s BumpSequenceResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BumpSequenceResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21493,6 +28481,21 @@ func (e CreateClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*CreateClaimableBalanceResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *CreateClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding CreateClaimableBalanceResultCode: %s", err)
+	}
+	if _, ok := createClaimableBalanceResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid CreateClaimableBalanceResultCode enum value", v)
+	}
+	*e = CreateClaimableBalanceResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21503,7 +28506,9 @@ func (s CreateClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21611,6 +28616,32 @@ func (u CreateClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*CreateClaimableBalanceResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *CreateClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding CreateClaimableBalanceResultCode: %s", err)
+	}
+	switch CreateClaimableBalanceResultCode(u.Code) {
+	case CreateClaimableBalanceResultCodeCreateClaimableBalanceSuccess:
+		u.BalanceId = new(ClaimableBalanceId)
+		nTmp, err = (*u.BalanceId).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimableBalanceId: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CreateClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21621,7 +28652,9 @@ func (s CreateClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CreateClaimableBalanceResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21691,6 +28724,21 @@ func (e ClaimClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClaimClaimableBalanceResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClaimClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimClaimableBalanceResultCode: %s", err)
+	}
+	if _, ok := claimClaimableBalanceResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClaimClaimableBalanceResultCode enum value", v)
+	}
+	*e = ClaimClaimableBalanceResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21701,7 +28749,9 @@ func (s ClaimClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21775,6 +28825,27 @@ func (u ClaimClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ClaimClaimableBalanceResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClaimClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClaimClaimableBalanceResultCode: %s", err)
+	}
+	switch ClaimClaimableBalanceResultCode(u.Code) {
+	case ClaimClaimableBalanceResultCodeClaimClaimableBalanceSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClaimClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21785,7 +28856,9 @@ func (s ClaimClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClaimClaimableBalanceResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21851,6 +28924,21 @@ func (e BeginSponsoringFutureReservesResultCode) EncodeTo(enc *xdr.Encoder) erro
 	return err
 }
 
+var _ decoderFrom = (*BeginSponsoringFutureReservesResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *BeginSponsoringFutureReservesResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding BeginSponsoringFutureReservesResultCode: %s", err)
+	}
+	if _, ok := beginSponsoringFutureReservesResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid BeginSponsoringFutureReservesResultCode enum value", v)
+	}
+	*e = BeginSponsoringFutureReservesResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BeginSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21861,7 +28949,9 @@ func (s BeginSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error)
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BeginSponsoringFutureReservesResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -21936,6 +29026,27 @@ func (u BeginSponsoringFutureReservesResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*BeginSponsoringFutureReservesResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *BeginSponsoringFutureReservesResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding BeginSponsoringFutureReservesResultCode: %s", err)
+	}
+	switch BeginSponsoringFutureReservesResultCode(u.Code) {
+	case BeginSponsoringFutureReservesResultCodeBeginSponsoringFutureReservesSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s BeginSponsoringFutureReservesResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -21946,7 +29057,9 @@ func (s BeginSponsoringFutureReservesResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *BeginSponsoringFutureReservesResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22006,6 +29119,21 @@ func (e EndSponsoringFutureReservesResultCode) EncodeTo(enc *xdr.Encoder) error
 	return err
 }
 
+var _ decoderFrom = (*EndSponsoringFutureReservesResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *EndSponsoringFutureReservesResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding EndSponsoringFutureReservesResultCode: %s", err)
+	}
+	if _, ok := endSponsoringFutureReservesResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid EndSponsoringFutureReservesResultCode enum value", v)
+	}
+	*e = EndSponsoringFutureReservesResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s EndSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22016,7 +29144,9 @@ func (s EndSponsoringFutureReservesResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *EndSponsoringFutureReservesResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22091,6 +29221,27 @@ func (u EndSponsoringFutureReservesResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*EndSponsoringFutureReservesResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *EndSponsoringFutureReservesResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding EndSponsoringFutureReservesResultCode: %s", err)
+	}
+	switch EndSponsoringFutureReservesResultCode(u.Code) {
+	case EndSponsoringFutureReservesResultCodeEndSponsoringFutureReservesSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s EndSponsoringFutureReservesResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22101,7 +29252,9 @@ func (s EndSponsoringFutureReservesResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *EndSponsoringFutureReservesResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22173,6 +29326,21 @@ func (e RevokeSponsorshipResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*RevokeSponsorshipResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *RevokeSponsorshipResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding RevokeSponsorshipResultCode: %s", err)
+	}
+	if _, ok := revokeSponsorshipResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid RevokeSponsorshipResultCode enum value", v)
+	}
+	*e = RevokeSponsorshipResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s RevokeSponsorshipResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22183,7 +29351,9 @@ func (s RevokeSponsorshipResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *RevokeSponsorshipResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22257,6 +29427,27 @@ func (u RevokeSponsorshipResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*RevokeSponsorshipResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *RevokeSponsorshipResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding RevokeSponsorshipResultCode: %s", err)
+	}
+	switch RevokeSponsorshipResultCode(u.Code) {
+	case RevokeSponsorshipResultCodeRevokeSponsorshipSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s RevokeSponsorshipResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22267,7 +29458,9 @@ func (s RevokeSponsorshipResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *RevokeSponsorshipResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22336,6 +29529,21 @@ func (e ClawbackResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClawbackResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClawbackResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClawbackResultCode: %s", err)
+	}
+	if _, ok := clawbackResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClawbackResultCode enum value", v)
+	}
+	*e = ClawbackResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22346,7 +29554,9 @@ func (s ClawbackResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22420,6 +29630,27 @@ func (u ClawbackResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ClawbackResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClawbackResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClawbackResultCode: %s", err)
+	}
+	switch ClawbackResultCode(u.Code) {
+	case ClawbackResultCodeClawbackSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22430,7 +29661,9 @@ func (s ClawbackResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22496,6 +29729,21 @@ func (e ClawbackClaimableBalanceResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*ClawbackClaimableBalanceResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *ClawbackClaimableBalanceResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding ClawbackClaimableBalanceResultCode: %s", err)
+	}
+	if _, ok := clawbackClaimableBalanceResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid ClawbackClaimableBalanceResultCode enum value", v)
+	}
+	*e = ClawbackClaimableBalanceResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22506,7 +29754,9 @@ func (s ClawbackClaimableBalanceResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackClaimableBalanceResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22581,6 +29831,27 @@ func (u ClawbackClaimableBalanceResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*ClawbackClaimableBalanceResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *ClawbackClaimableBalanceResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding ClawbackClaimableBalanceResultCode: %s", err)
+	}
+	switch ClawbackClaimableBalanceResultCode(u.Code) {
+	case ClawbackClaimableBalanceResultCodeClawbackClaimableBalanceSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s ClawbackClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22591,7 +29862,9 @@ func (s ClawbackClaimableBalanceResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *ClawbackClaimableBalanceResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22664,6 +29937,21 @@ func (e SetTrustLineFlagsResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*SetTrustLineFlagsResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *SetTrustLineFlagsResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding SetTrustLineFlagsResultCode: %s", err)
+	}
+	if _, ok := setTrustLineFlagsResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid SetTrustLineFlagsResultCode enum value", v)
+	}
+	*e = SetTrustLineFlagsResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetTrustLineFlagsResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22674,7 +29962,9 @@ func (s SetTrustLineFlagsResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetTrustLineFlagsResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22748,6 +30038,27 @@ func (u SetTrustLineFlagsResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*SetTrustLineFlagsResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *SetTrustLineFlagsResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SetTrustLineFlagsResultCode: %s", err)
+	}
+	switch SetTrustLineFlagsResultCode(u.Code) {
+	case SetTrustLineFlagsResultCodeSetTrustLineFlagsSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SetTrustLineFlagsResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22758,7 +30069,9 @@ func (s SetTrustLineFlagsResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SetTrustLineFlagsResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22840,6 +30153,21 @@ func (e LiquidityPoolDepositResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LiquidityPoolDepositResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LiquidityPoolDepositResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolDepositResultCode: %s", err)
+	}
+	if _, ok := liquidityPoolDepositResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LiquidityPoolDepositResultCode enum value", v)
+	}
+	*e = LiquidityPoolDepositResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolDepositResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22850,7 +30178,9 @@ func (s LiquidityPoolDepositResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolDepositResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -22925,6 +30255,27 @@ func (u LiquidityPoolDepositResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*LiquidityPoolDepositResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LiquidityPoolDepositResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolDepositResultCode: %s", err)
+	}
+	switch LiquidityPoolDepositResultCode(u.Code) {
+	case LiquidityPoolDepositResultCodeLiquidityPoolDepositSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolDepositResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -22935,7 +30286,9 @@ func (s LiquidityPoolDepositResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolDepositResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -23010,6 +30363,21 @@ func (e LiquidityPoolWithdrawResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*LiquidityPoolWithdrawResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *LiquidityPoolWithdrawResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolWithdrawResultCode: %s", err)
+	}
+	if _, ok := liquidityPoolWithdrawResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid LiquidityPoolWithdrawResultCode enum value", v)
+	}
+	*e = LiquidityPoolWithdrawResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolWithdrawResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -23020,7 +30388,9 @@ func (s LiquidityPoolWithdrawResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolWithdrawResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -23095,6 +30465,27 @@ func (u LiquidityPoolWithdrawResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*LiquidityPoolWithdrawResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *LiquidityPoolWithdrawResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding LiquidityPoolWithdrawResultCode: %s", err)
+	}
+	switch LiquidityPoolWithdrawResultCode(u.Code) {
+	case LiquidityPoolWithdrawResultCodeLiquidityPoolWithdrawSuccess:
+		// Void
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s LiquidityPoolWithdrawResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -23105,7 +30496,9 @@ func (s LiquidityPoolWithdrawResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *LiquidityPoolWithdrawResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -23178,6 +30571,21 @@ func (e OperationResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*OperationResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *OperationResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationResultCode: %s", err)
+	}
+	if _, ok := operationResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid OperationResultCode enum value", v)
+	}
+	*e = OperationResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -23188,7 +30596,9 @@ func (s OperationResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24254,6 +31664,214 @@ func (u OperationResultTr) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (OperationType) switch value '%d' is not valid for union OperationResultTr", u.Type)
 }
 
+var _ decoderFrom = (*OperationResultTr)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *OperationResultTr) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationType: %s", err)
+	}
+	switch OperationType(u.Type) {
+	case OperationTypeCreateAccount:
+		u.CreateAccountResult = new(CreateAccountResult)
+		nTmp, err = (*u.CreateAccountResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding CreateAccountResult: %s", err)
+		}
+		return n, nil
+	case OperationTypePayment:
+		u.PaymentResult = new(PaymentResult)
+		nTmp, err = (*u.PaymentResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PaymentResult: %s", err)
+		}
+		return n, nil
+	case OperationTypePathPaymentStrictReceive:
+		u.PathPaymentStrictReceiveResult = new(PathPaymentStrictReceiveResult)
+		nTmp, err = (*u.PathPaymentStrictReceiveResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictReceiveResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeManageSellOffer:
+		u.ManageSellOfferResult = new(ManageSellOfferResult)
+		nTmp, err = (*u.ManageSellOfferResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageSellOfferResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeCreatePassiveSellOffer:
+		u.CreatePassiveSellOfferResult = new(ManageSellOfferResult)
+		nTmp, err = (*u.CreatePassiveSellOfferResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageSellOfferResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeSetOptions:
+		u.SetOptionsResult = new(SetOptionsResult)
+		nTmp, err = (*u.SetOptionsResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SetOptionsResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeChangeTrust:
+		u.ChangeTrustResult = new(ChangeTrustResult)
+		nTmp, err = (*u.ChangeTrustResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ChangeTrustResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeAllowTrust:
+		u.AllowTrustResult = new(AllowTrustResult)
+		nTmp, err = (*u.AllowTrustResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AllowTrustResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeAccountMerge:
+		u.AccountMergeResult = new(AccountMergeResult)
+		nTmp, err = (*u.AccountMergeResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding AccountMergeResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeInflation:
+		u.InflationResult = new(InflationResult)
+		nTmp, err = (*u.InflationResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding InflationResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeManageData:
+		u.ManageDataResult = new(ManageDataResult)
+		nTmp, err = (*u.ManageDataResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageDataResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeBumpSequence:
+		u.BumpSeqResult = new(BumpSequenceResult)
+		nTmp, err = (*u.BumpSeqResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding BumpSequenceResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeManageBuyOffer:
+		u.ManageBuyOfferResult = new(ManageBuyOfferResult)
+		nTmp, err = (*u.ManageBuyOfferResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ManageBuyOfferResult: %s", err)
+		}
+		return n, nil
+	case OperationTypePathPaymentStrictSend:
+		u.PathPaymentStrictSendResult = new(PathPaymentStrictSendResult)
+		nTmp, err = (*u.PathPaymentStrictSendResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding PathPaymentStrictSendResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeCreateClaimableBalance:
+		u.CreateClaimableBalanceResult = new(CreateClaimableBalanceResult)
+		nTmp, err = (*u.CreateClaimableBalanceResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding CreateClaimableBalanceResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeClaimClaimableBalance:
+		u.ClaimClaimableBalanceResult = new(ClaimClaimableBalanceResult)
+		nTmp, err = (*u.ClaimClaimableBalanceResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClaimClaimableBalanceResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeBeginSponsoringFutureReserves:
+		u.BeginSponsoringFutureReservesResult = new(BeginSponsoringFutureReservesResult)
+		nTmp, err = (*u.BeginSponsoringFutureReservesResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding BeginSponsoringFutureReservesResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeEndSponsoringFutureReserves:
+		u.EndSponsoringFutureReservesResult = new(EndSponsoringFutureReservesResult)
+		nTmp, err = (*u.EndSponsoringFutureReservesResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding EndSponsoringFutureReservesResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeRevokeSponsorship:
+		u.RevokeSponsorshipResult = new(RevokeSponsorshipResult)
+		nTmp, err = (*u.RevokeSponsorshipResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding RevokeSponsorshipResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeClawback:
+		u.ClawbackResult = new(ClawbackResult)
+		nTmp, err = (*u.ClawbackResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClawbackResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeClawbackClaimableBalance:
+		u.ClawbackClaimableBalanceResult = new(ClawbackClaimableBalanceResult)
+		nTmp, err = (*u.ClawbackClaimableBalanceResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding ClawbackClaimableBalanceResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeSetTrustLineFlags:
+		u.SetTrustLineFlagsResult = new(SetTrustLineFlagsResult)
+		nTmp, err = (*u.SetTrustLineFlagsResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding SetTrustLineFlagsResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeLiquidityPoolDeposit:
+		u.LiquidityPoolDepositResult = new(LiquidityPoolDepositResult)
+		nTmp, err = (*u.LiquidityPoolDepositResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolDepositResult: %s", err)
+		}
+		return n, nil
+	case OperationTypeLiquidityPoolWithdraw:
+		u.LiquidityPoolWithdrawResult = new(LiquidityPoolWithdrawResult)
+		nTmp, err = (*u.LiquidityPoolWithdrawResult).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding LiquidityPoolWithdrawResult: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union OperationResultTr has invalid Type (OperationType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationResultTr) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24264,7 +31882,9 @@ func (s OperationResultTr) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationResultTr) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24422,6 +32042,32 @@ func (u OperationResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*OperationResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *OperationResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding OperationResultCode: %s", err)
+	}
+	switch OperationResultCode(u.Code) {
+	case OperationResultCodeOpInner:
+		u.Tr = new(OperationResultTr)
+		nTmp, err = (*u.Tr).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationResultTr: %s", err)
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s OperationResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24432,7 +32078,9 @@ func (s OperationResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *OperationResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24535,6 +32183,21 @@ func (e TransactionResultCode) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*TransactionResultCode)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *TransactionResultCode) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultCode: %s", err)
+	}
+	if _, ok := transactionResultCodeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid TransactionResultCode enum value", v)
+	}
+	*e = TransactionResultCode(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultCode) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24545,7 +32208,9 @@ func (s TransactionResultCode) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultCode) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24769,6 +32434,98 @@ func (u InnerTransactionResultResult) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Code (TransactionResultCode) switch value '%d' is not valid for union InnerTransactionResultResult", u.Code)
 }
 
+var _ decoderFrom = (*InnerTransactionResultResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *InnerTransactionResultResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultCode: %s", err)
+	}
+	switch TransactionResultCode(u.Code) {
+	case TransactionResultCodeTxSuccess:
+		u.Results = new([]OperationResult)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationResult: %s", err)
+		}
+		(*u.Results) = nil
+		if l > 0 {
+			(*u.Results) = make([]OperationResult, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Results)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding OperationResult: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case TransactionResultCodeTxFailed:
+		u.Results = new([]OperationResult)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationResult: %s", err)
+		}
+		(*u.Results) = nil
+		if l > 0 {
+			(*u.Results) = make([]OperationResult, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Results)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding OperationResult: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case TransactionResultCodeTxTooEarly:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxTooLate:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxMissingOperation:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxBadSeq:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxBadAuth:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxInsufficientBalance:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxNoAccount:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxInsufficientFee:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxBadAuthExtra:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxInternalError:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxNotSupported:
+		// Void
+		return n, nil
+	case TransactionResultCodeTxBadSponsorship:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union InnerTransactionResultResult has invalid Code (TransactionResultCode) switch value '%d'", u.Code)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InnerTransactionResultResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24779,7 +32536,9 @@ func (s InnerTransactionResultResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InnerTransactionResultResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24846,6 +32605,25 @@ func (u InnerTransactionResultExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union InnerTransactionResultExt", u.V)
 }
 
+var _ decoderFrom = (*InnerTransactionResultExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *InnerTransactionResultExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union InnerTransactionResultExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InnerTransactionResultExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24856,7 +32634,9 @@ func (s InnerTransactionResultExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InnerTransactionResultExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24931,6 +32711,30 @@ func (s *InnerTransactionResult) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*InnerTransactionResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *InnerTransactionResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.FeeCharged.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Result.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding InnerTransactionResultResult: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding InnerTransactionResultExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InnerTransactionResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24941,7 +32745,9 @@ func (s InnerTransactionResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InnerTransactionResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -24981,6 +32787,25 @@ func (s *InnerTransactionResultPair) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*InnerTransactionResultPair)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *InnerTransactionResultPair) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.TransactionHash.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	nTmp, err = s.Result.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding InnerTransactionResult: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s InnerTransactionResultPair) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -24991,7 +32816,9 @@ func (s InnerTransactionResultPair) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *InnerTransactionResultPair) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25180,6 +33007,80 @@ func (u TransactionResultResult) EncodeTo(e *xdr.Encoder) error {
 	}
 }
 
+var _ decoderFrom = (*TransactionResultResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionResultResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Code.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultCode: %s", err)
+	}
+	switch TransactionResultCode(u.Code) {
+	case TransactionResultCodeTxFeeBumpInnerSuccess:
+		u.InnerResultPair = new(InnerTransactionResultPair)
+		nTmp, err = (*u.InnerResultPair).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding InnerTransactionResultPair: %s", err)
+		}
+		return n, nil
+	case TransactionResultCodeTxFeeBumpInnerFailed:
+		u.InnerResultPair = new(InnerTransactionResultPair)
+		nTmp, err = (*u.InnerResultPair).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding InnerTransactionResultPair: %s", err)
+		}
+		return n, nil
+	case TransactionResultCodeTxSuccess:
+		u.Results = new([]OperationResult)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationResult: %s", err)
+		}
+		(*u.Results) = nil
+		if l > 0 {
+			(*u.Results) = make([]OperationResult, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Results)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding OperationResult: %s", err)
+				}
+			}
+		}
+		return n, nil
+	case TransactionResultCodeTxFailed:
+		u.Results = new([]OperationResult)
+		var l uint32
+		l, nTmp, err = d.DecodeUint()
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding OperationResult: %s", err)
+		}
+		(*u.Results) = nil
+		if l > 0 {
+			(*u.Results) = make([]OperationResult, l)
+			for i := uint32(0); i < l; i++ {
+				nTmp, err = (*u.Results)[i].DecodeFrom(d)
+				n += nTmp
+				if err != nil {
+					return n, fmt.Errorf("decoding OperationResult: %s", err)
+				}
+			}
+		}
+		return n, nil
+	default:
+		// Void
+		return n, nil
+	}
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25190,7 +33091,9 @@ func (s TransactionResultResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25257,6 +33160,25 @@ func (u TransactionResultExt) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("V (int32) switch value '%d' is not valid for union TransactionResultExt", u.V)
 }
 
+var _ decoderFrom = (*TransactionResultExt)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *TransactionResultExt) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	u.V, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	switch int32(u.V) {
+	case 0:
+		// Void
+		return n, nil
+	}
+	return n, fmt.Errorf("union TransactionResultExt has invalid V (int32) switch value '%d'", u.V)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResultExt) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25267,7 +33189,9 @@ func (s TransactionResultExt) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResultExt) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25331,6 +33255,30 @@ func (s *TransactionResult) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*TransactionResult)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *TransactionResult) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = s.FeeCharged.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int64: %s", err)
+	}
+	nTmp, err = s.Result.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultResult: %s", err)
+	}
+	nTmp, err = s.Ext.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding TransactionResultExt: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s TransactionResult) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25341,7 +33289,9 @@ func (s TransactionResult) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *TransactionResult) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25376,6 +33326,20 @@ func (s *Hash) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Hash)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Hash) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hash: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Hash) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25386,7 +33350,9 @@ func (s Hash) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Hash) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25421,6 +33387,20 @@ func (s *Uint256) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Uint256)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Uint256) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Uint256: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Uint256) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25431,7 +33411,9 @@ func (s Uint256) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Uint256) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25461,6 +33443,22 @@ func (s Uint32) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Uint32)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Uint32) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v uint32
+	v, nTmp, err = d.DecodeUint()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Unsigned int: %s", err)
+	}
+	*s = Uint32(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Uint32) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25471,7 +33469,9 @@ func (s Uint32) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Uint32) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25501,6 +33501,22 @@ func (s Int32) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Int32)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Int32) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v int32
+	v, nTmp, err = d.DecodeInt()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Int: %s", err)
+	}
+	*s = Int32(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Int32) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25511,7 +33527,9 @@ func (s Int32) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Int32) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25541,6 +33559,22 @@ func (s Uint64) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Uint64)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Uint64) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v uint64
+	v, nTmp, err = d.DecodeUhyper()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Unsigned hyper: %s", err)
+	}
+	*s = Uint64(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Uint64) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25551,7 +33585,9 @@ func (s Uint64) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Uint64) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25581,6 +33617,22 @@ func (s Int64) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Int64)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Int64) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	var v int64
+	v, nTmp, err = d.DecodeHyper()
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Hyper: %s", err)
+	}
+	*s = Int64(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Int64) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25591,7 +33643,9 @@ func (s Int64) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Int64) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25656,6 +33710,21 @@ func (e CryptoKeyType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*CryptoKeyType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *CryptoKeyType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding CryptoKeyType: %s", err)
+	}
+	if _, ok := cryptoKeyTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid CryptoKeyType enum value", v)
+	}
+	*e = CryptoKeyType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s CryptoKeyType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25666,7 +33735,9 @@ func (s CryptoKeyType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *CryptoKeyType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25720,6 +33791,21 @@ func (e PublicKeyType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*PublicKeyType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *PublicKeyType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding PublicKeyType: %s", err)
+	}
+	if _, ok := publicKeyTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid PublicKeyType enum value", v)
+	}
+	*e = PublicKeyType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PublicKeyType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25730,7 +33816,9 @@ func (s PublicKeyType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PublicKeyType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25790,6 +33878,21 @@ func (e SignerKeyType) EncodeTo(enc *xdr.Encoder) error {
 	return err
 }
 
+var _ decoderFrom = (*SignerKeyType)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (e *SignerKeyType) DecodeFrom(d *xdr.Decoder) (int, error) {
+	v, n, err := d.DecodeInt()
+	if err != nil {
+		return n, fmt.Errorf("decoding SignerKeyType: %s", err)
+	}
+	if _, ok := signerKeyTypeMap[v]; !ok {
+		return n, fmt.Errorf("'%d' is not a valid SignerKeyType enum value", v)
+	}
+	*e = SignerKeyType(v)
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SignerKeyType) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25800,7 +33903,9 @@ func (s SignerKeyType) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SignerKeyType) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -25900,6 +34005,30 @@ func (u PublicKey) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (PublicKeyType) switch value '%d' is not valid for union PublicKey", u.Type)
 }
 
+var _ decoderFrom = (*PublicKey)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *PublicKey) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PublicKeyType: %s", err)
+	}
+	switch PublicKeyType(u.Type) {
+	case PublicKeyTypePublicKeyTypeEd25519:
+		u.Ed25519 = new(Uint256)
+		nTmp, err = (*u.Ed25519).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union PublicKey has invalid Type (PublicKeyType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s PublicKey) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -25910,7 +34039,9 @@ func (s PublicKey) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *PublicKey) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26096,6 +34227,46 @@ func (u SignerKey) EncodeTo(e *xdr.Encoder) error {
 	return fmt.Errorf("Type (SignerKeyType) switch value '%d' is not valid for union SignerKey", u.Type)
 }
 
+var _ decoderFrom = (*SignerKey)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (u *SignerKey) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = u.Type.DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SignerKeyType: %s", err)
+	}
+	switch SignerKeyType(u.Type) {
+	case SignerKeyTypeSignerKeyTypeEd25519:
+		u.Ed25519 = new(Uint256)
+		nTmp, err = (*u.Ed25519).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	case SignerKeyTypeSignerKeyTypePreAuthTx:
+		u.PreAuthTx = new(Uint256)
+		nTmp, err = (*u.PreAuthTx).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	case SignerKeyTypeSignerKeyTypeHashX:
+		u.HashX = new(Uint256)
+		nTmp, err = (*u.HashX).DecodeFrom(d)
+		n += nTmp
+		if err != nil {
+			return n, fmt.Errorf("decoding Uint256: %s", err)
+		}
+		return n, nil
+	}
+	return n, fmt.Errorf("union SignerKey has invalid Type (SignerKeyType) switch value '%d'", u.Type)
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SignerKey) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26106,7 +34277,9 @@ func (s SignerKey) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SignerKey) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26141,6 +34314,20 @@ func (s Signature) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Signature)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Signature) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	(*s), nTmp, err = d.DecodeOpaque(64)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Signature: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Signature) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26151,7 +34338,9 @@ func (s Signature) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Signature) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26186,6 +34375,20 @@ func (s *SignatureHint) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*SignatureHint)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *SignatureHint) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding SignatureHint: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s SignatureHint) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26196,7 +34399,9 @@ func (s SignatureHint) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *SignatureHint) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26257,6 +34462,20 @@ func (s NodeId) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*NodeId)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *NodeId) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = (*PublicKey)(s).DecodeFrom(d)
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding PublicKey: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s NodeId) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26267,7 +34486,9 @@ func (s NodeId) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *NodeId) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26302,6 +34523,20 @@ func (s *Curve25519Secret) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Curve25519Secret)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Curve25519Secret) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s.Key[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Key: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Curve25519Secret) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26312,7 +34547,9 @@ func (s Curve25519Secret) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Curve25519Secret) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26347,6 +34584,20 @@ func (s *Curve25519Public) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*Curve25519Public)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *Curve25519Public) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s.Key[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Key: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s Curve25519Public) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26357,7 +34608,9 @@ func (s Curve25519Public) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *Curve25519Public) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26392,6 +34645,20 @@ func (s *HmacSha256Key) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*HmacSha256Key)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *HmacSha256Key) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s.Key[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Key: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s HmacSha256Key) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26402,7 +34669,9 @@ func (s HmacSha256Key) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *HmacSha256Key) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }
 
@@ -26437,6 +34706,20 @@ func (s *HmacSha256Mac) EncodeTo(e *xdr.Encoder) error {
 	return nil
 }
 
+var _ decoderFrom = (*HmacSha256Mac)(nil)
+
+// DecodeFrom decodes this value using the Decoder.
+func (s *HmacSha256Mac) DecodeFrom(d *xdr.Decoder) (int, error) {
+	var err error
+	var n, nTmp int
+	nTmp, err = d.DecodeFixedOpaqueInplace(s.Mac[:])
+	n += nTmp
+	if err != nil {
+		return n, fmt.Errorf("decoding Mac: %s", err)
+	}
+	return n, nil
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler.
 func (s HmacSha256Mac) MarshalBinary() ([]byte, error) {
 	b := bytes.Buffer{}
@@ -26447,7 +34730,9 @@ func (s HmacSha256Mac) MarshalBinary() ([]byte, error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler.
 func (s *HmacSha256Mac) UnmarshalBinary(inp []byte) error {
-	_, err := Unmarshal(bytes.NewReader(inp), s)
+	r := bytes.NewReader(inp)
+	d := xdr.NewDecoder(r)
+	_, err := s.DecodeFrom(d)
 	return err
 }