Update and fix XDR

src/main/java/org/stellar/sdk/xdr/AccountEntry.java

@@ -168,8 +168,10 @@ public static void encode(XdrDataOutputStream stream, AccountEntryExt encodedAcc
     }
     }
     public static AccountEntryExt decode(XdrDataInputStream stream) throws IOException {
-      AccountEntryExt decodedAccountEntryExt = new AccountEntryExt();
-      switch (decodedAccountEntryExt.getDiscriminant()) {
+    AccountEntryExt decodedAccountEntryExt = new AccountEntryExt();
+    Integer discriminant = stream.readInt();
+    decodedAccountEntryExt.setDiscriminant(discriminant);
+    switch (decodedAccountEntryExt.getDiscriminant()) {
     case 0:
     break;
     }

src/main/java/org/stellar/sdk/xdr/AccountMergeResult.java

@@ -44,8 +44,10 @@ public static void encode(XdrDataOutputStream stream, AccountMergeResult encoded
   }
   }
   public static AccountMergeResult decode(XdrDataInputStream stream) throws IOException {
-    AccountMergeResult decodedAccountMergeResult = new AccountMergeResult();
-    switch (decodedAccountMergeResult.getDiscriminant()) {
+  AccountMergeResult decodedAccountMergeResult = new AccountMergeResult();
+  AccountMergeResultCode discriminant = AccountMergeResultCode.decode(stream);
+  decodedAccountMergeResult.setDiscriminant(discriminant);
+  switch (decodedAccountMergeResult.getDiscriminant()) {
   case ACCOUNT_MERGE_SUCCESS:
   decodedAccountMergeResult.sourceAccountBalance = Int64.decode(stream);
   break;

src/main/java/org/stellar/sdk/xdr/AllowTrustOp.java

@@ -101,8 +101,10 @@ public static void encode(XdrDataOutputStream stream, AllowTrustOpAsset encodedA
     }
     }
     public static AllowTrustOpAsset decode(XdrDataInputStream stream) throws IOException {
-      AllowTrustOpAsset decodedAllowTrustOpAsset = new AllowTrustOpAsset();
-      switch (decodedAllowTrustOpAsset.getDiscriminant()) {
+    AllowTrustOpAsset decodedAllowTrustOpAsset = new AllowTrustOpAsset();
+    AssetType discriminant = AssetType.decode(stream);
+    decodedAllowTrustOpAsset.setDiscriminant(discriminant);
+    switch (decodedAllowTrustOpAsset.getDiscriminant()) {
     case ASSET_TYPE_CREDIT_ALPHANUM4:
     int assetCode4size = 4;
     decodedAllowTrustOpAsset.assetCode4 = new byte[assetCode4size];

src/main/java/org/stellar/sdk/xdr/AllowTrustResult.java

@@ -36,8 +36,10 @@ public static void encode(XdrDataOutputStream stream, AllowTrustResult encodedAl
   }
   }
   public static AllowTrustResult decode(XdrDataInputStream stream) throws IOException {
-    AllowTrustResult decodedAllowTrustResult = new AllowTrustResult();
-    switch (decodedAllowTrustResult.getDiscriminant()) {
+  AllowTrustResult decodedAllowTrustResult = new AllowTrustResult();
+  AllowTrustResultCode discriminant = AllowTrustResultCode.decode(stream);
+  decodedAllowTrustResult.setDiscriminant(discriminant);
+  switch (decodedAllowTrustResult.getDiscriminant()) {
   case ALLOW_TRUST_SUCCESS:
   break;
   default:

src/main/java/org/stellar/sdk/xdr/Asset.java

@@ -68,8 +68,10 @@ public static void encode(XdrDataOutputStream stream, Asset encodedAsset) throws
   }
   }
   public static Asset decode(XdrDataInputStream stream) throws IOException {
-    Asset decodedAsset = new Asset();
-    switch (decodedAsset.getDiscriminant()) {
+  Asset decodedAsset = new Asset();
+  AssetType discriminant = AssetType.decode(stream);
+  decodedAsset.setDiscriminant(discriminant);
+  switch (decodedAsset.getDiscriminant()) {
   case ASSET_TYPE_NATIVE:
   break;
   case ASSET_TYPE_CREDIT_ALPHANUM4:

src/main/java/org/stellar/sdk/xdr/AuthenticatedMessage.java

@@ -8,47 +8,89 @@
 
 // === xdr source ============================================================
 
-//  struct AuthenticatedMessage
+//  union AuthenticatedMessage switch (uint32 v)
+//  {
+//  case 0:
+//      struct
 //  {
 //     uint64 sequence;
 //     StellarMessage message;
 //     HmacSha256Mac mac;
+//      } v0;
 //  };
 
 //  ===========================================================================
 public class AuthenticatedMessage  {
   public AuthenticatedMessage () {}
-  private Uint64 sequence;
-  public Uint64 getSequence() {
-    return this.sequence;
-  }
-  public void setSequence(Uint64 value) {
-    this.sequence = value;
+  Uint32 v;
+  public Uint32 getDiscriminant() {
+    return this.v;
   }
-  private StellarMessage message;
-  public StellarMessage getMessage() {
-    return this.message;
+  public void setDiscriminant(Uint32 value) {
+    this.v = value;
   }
-  public void setMessage(StellarMessage value) {
-    this.message = value;
+  private AuthenticatedMessageV0 v0;
+  public AuthenticatedMessageV0 getV0() {
+    return this.v0;
   }
-  private HmacSha256Mac mac;
-  public HmacSha256Mac getMac() {
-    return this.mac;
+  public void setV0(AuthenticatedMessageV0 value) {
+    this.v0 = value;
   }
-  public void setMac(HmacSha256Mac value) {
-    this.mac = value;
+  public static void encode(XdrDataOutputStream stream, AuthenticatedMessage encodedAuthenticatedMessage) throws IOException {
+  stream.writeInt(encodedAuthenticatedMessage.getDiscriminant().getUint32());
+  switch (encodedAuthenticatedMessage.getDiscriminant().getUint32()) {
+  case 0:
+  AuthenticatedMessageV0.encode(stream, encodedAuthenticatedMessage.v0);
+  break;
   }
-  public static void encode(XdrDataOutputStream stream, AuthenticatedMessage encodedAuthenticatedMessage) throws IOException{
-    Uint64.encode(stream, encodedAuthenticatedMessage.sequence);
-    StellarMessage.encode(stream, encodedAuthenticatedMessage.message);
-    HmacSha256Mac.encode(stream, encodedAuthenticatedMessage.mac);
   }
   public static AuthenticatedMessage decode(XdrDataInputStream stream) throws IOException {
-    AuthenticatedMessage decodedAuthenticatedMessage = new AuthenticatedMessage();
-    decodedAuthenticatedMessage.sequence = Uint64.decode(stream);
-    decodedAuthenticatedMessage.message = StellarMessage.decode(stream);
-    decodedAuthenticatedMessage.mac = HmacSha256Mac.decode(stream);
+  AuthenticatedMessage decodedAuthenticatedMessage = new AuthenticatedMessage();
+  Uint32 discriminant = Uint32.decode(stream);
+  decodedAuthenticatedMessage.setDiscriminant(discriminant);
+  switch (decodedAuthenticatedMessage.getDiscriminant().getUint32()) {
+  case 0:
+  decodedAuthenticatedMessage.v0 = AuthenticatedMessageV0.decode(stream);
+  break;
+  }
     return decodedAuthenticatedMessage;
   }
+
+  public static class AuthenticatedMessageV0 {
+    public AuthenticatedMessageV0 () {}
+    private Uint64 sequence;
+    public Uint64 getSequence() {
+      return this.sequence;
+    }
+    public void setSequence(Uint64 value) {
+      this.sequence = value;
+    }
+    private StellarMessage message;
+    public StellarMessage getMessage() {
+      return this.message;
+    }
+    public void setMessage(StellarMessage value) {
+      this.message = value;
+    }
+    private HmacSha256Mac mac;
+    public HmacSha256Mac getMac() {
+      return this.mac;
+    }
+    public void setMac(HmacSha256Mac value) {
+      this.mac = value;
+    }
+    public static void encode(XdrDataOutputStream stream, AuthenticatedMessageV0 encodedAuthenticatedMessageV0) throws IOException{
+      Uint64.encode(stream, encodedAuthenticatedMessageV0.sequence);
+      StellarMessage.encode(stream, encodedAuthenticatedMessageV0.message);
+      HmacSha256Mac.encode(stream, encodedAuthenticatedMessageV0.mac);
+    }
+    public static AuthenticatedMessageV0 decode(XdrDataInputStream stream) throws IOException {
+      AuthenticatedMessageV0 decodedAuthenticatedMessageV0 = new AuthenticatedMessageV0();
+      decodedAuthenticatedMessageV0.sequence = Uint64.decode(stream);
+      decodedAuthenticatedMessageV0.message = StellarMessage.decode(stream);
+      decodedAuthenticatedMessageV0.mac = HmacSha256Mac.decode(stream);
+      return decodedAuthenticatedMessageV0;
+    }
+
+  }
 }

src/main/java/org/stellar/sdk/xdr/BucketEntry.java

@@ -53,8 +53,10 @@ public static void encode(XdrDataOutputStream stream, BucketEntry encodedBucketE
   }
   }
   public static BucketEntry decode(XdrDataInputStream stream) throws IOException {
-    BucketEntry decodedBucketEntry = new BucketEntry();
-    switch (decodedBucketEntry.getDiscriminant()) {
+  BucketEntry decodedBucketEntry = new BucketEntry();
+  BucketEntryType discriminant = BucketEntryType.decode(stream);
+  decodedBucketEntry.setDiscriminant(discriminant);
+  switch (decodedBucketEntry.getDiscriminant()) {
   case LIVEENTRY:
   decodedBucketEntry.liveEntry = LedgerEntry.decode(stream);
   break;

src/main/java/org/stellar/sdk/xdr/ChangeTrustResult.java

@@ -36,8 +36,10 @@ public static void encode(XdrDataOutputStream stream, ChangeTrustResult encodedC
   }
   }
   public static ChangeTrustResult decode(XdrDataInputStream stream) throws IOException {
-    ChangeTrustResult decodedChangeTrustResult = new ChangeTrustResult();
-    switch (decodedChangeTrustResult.getDiscriminant()) {
+  ChangeTrustResult decodedChangeTrustResult = new ChangeTrustResult();
+  ChangeTrustResultCode discriminant = ChangeTrustResultCode.decode(stream);
+  decodedChangeTrustResult.setDiscriminant(discriminant);
+  switch (decodedChangeTrustResult.getDiscriminant()) {
   case CHANGE_TRUST_SUCCESS:
   break;
   default:

src/main/java/org/stellar/sdk/xdr/ClaimOfferAtom.java

@@ -10,7 +10,7 @@
 
 //  struct ClaimOfferAtom
 //  {
-//      // emited to identify the offer
+//      // emitted to identify the offer
 //      AccountID sellerID; // Account that owns the offer
 //      uint64 offerID;
 //  

src/main/java/org/stellar/sdk/xdr/CreateAccountResult.java

@@ -36,8 +36,10 @@ public static void encode(XdrDataOutputStream stream, CreateAccountResult encode
   }
   }
   public static CreateAccountResult decode(XdrDataInputStream stream) throws IOException {
-    CreateAccountResult decodedCreateAccountResult = new CreateAccountResult();
-    switch (decodedCreateAccountResult.getDiscriminant()) {
+  CreateAccountResult decodedCreateAccountResult = new CreateAccountResult();
+  CreateAccountResultCode discriminant = CreateAccountResultCode.decode(stream);
+  decodedCreateAccountResult.setDiscriminant(discriminant);
+  switch (decodedCreateAccountResult.getDiscriminant()) {
   case CREATE_ACCOUNT_SUCCESS:
   break;
   default:

src/main/java/org/stellar/sdk/xdr/DataEntry.java

@@ -0,0 +1,100 @@
+// Automatically generated by xdrgen 
+// DO NOT EDIT or your changes may be overwritten
+
+package org.stellar.sdk.xdr;
+
+
+import java.io.IOException;
+
+// === xdr source ============================================================
+
+//  struct DataEntry
+//  {
+//      AccountID accountID; // account this data belongs to
+//      string64 dataName;
+//      DataValue dataValue;
+//  
+//      // reserved for future use
+//      union switch (int v)
+//      {
+//      case 0:
+//          void;
+//      }
+//      ext;
+//  };
+
+//  ===========================================================================
+public class DataEntry  {
+  public DataEntry () {}
+  private AccountID accountID;
+  public AccountID getAccountID() {
+    return this.accountID;
+  }
+  public void setAccountID(AccountID value) {
+    this.accountID = value;
+  }
+  private String64 dataName;
+  public String64 getDataName() {
+    return this.dataName;
+  }
+  public void setDataName(String64 value) {
+    this.dataName = value;
+  }
+  private DataValue dataValue;
+  public DataValue getDataValue() {
+    return this.dataValue;
+  }
+  public void setDataValue(DataValue value) {
+    this.dataValue = value;
+  }
+  private DataEntryExt ext;
+  public DataEntryExt getExt() {
+    return this.ext;
+  }
+  public void setExt(DataEntryExt value) {
+    this.ext = value;
+  }
+  public static void encode(XdrDataOutputStream stream, DataEntry encodedDataEntry) throws IOException{
+    AccountID.encode(stream, encodedDataEntry.accountID);
+    String64.encode(stream, encodedDataEntry.dataName);
+    DataValue.encode(stream, encodedDataEntry.dataValue);
+    DataEntryExt.encode(stream, encodedDataEntry.ext);
+  }
+  public static DataEntry decode(XdrDataInputStream stream) throws IOException {
+    DataEntry decodedDataEntry = new DataEntry();
+    decodedDataEntry.accountID = AccountID.decode(stream);
+    decodedDataEntry.dataName = String64.decode(stream);
+    decodedDataEntry.dataValue = DataValue.decode(stream);
+    decodedDataEntry.ext = DataEntryExt.decode(stream);
+    return decodedDataEntry;
+  }
+
+  public static class DataEntryExt {
+    public DataEntryExt () {}
+    Integer v;
+    public Integer getDiscriminant() {
+      return this.v;
+    }
+    public void setDiscriminant(Integer value) {
+      this.v = value;
+    }
+    public static void encode(XdrDataOutputStream stream, DataEntryExt encodedDataEntryExt) throws IOException {
+    stream.writeInt(encodedDataEntryExt.getDiscriminant().intValue());
+    switch (encodedDataEntryExt.getDiscriminant()) {
+    case 0:
+    break;
+    }
+    }
+    public static DataEntryExt decode(XdrDataInputStream stream) throws IOException {
+    DataEntryExt decodedDataEntryExt = new DataEntryExt();
+    Integer discriminant = stream.readInt();
+    decodedDataEntryExt.setDiscriminant(discriminant);
+    switch (decodedDataEntryExt.getDiscriminant()) {
+    case 0:
+    break;
+    }
+      return decodedDataEntryExt;
+    }
+
+  }
+}

src/main/java/org/stellar/sdk/xdr/DataValue.java

@@ -0,0 +1,34 @@
+// Automatically generated by xdrgen 
+// DO NOT EDIT or your changes may be overwritten
+
+package org.stellar.sdk.xdr;
+
+
+import java.io.IOException;
+
+// === xdr source ============================================================
+
+//  typedef opaque DataValue<64>;
+
+//  ===========================================================================
+public class DataValue  {
+  private byte[] DataValue;
+  public byte[] getDataValue() {
+    return this.DataValue;
+  }
+  public void setDataValue(byte[] value) {
+    this.DataValue = value;
+  }
+  public static void encode(XdrDataOutputStream stream, DataValue  encodedDataValue) throws IOException {
+  int DataValuesize = encodedDataValue.DataValue.length;
+  stream.writeInt(DataValuesize);
+  stream.write(encodedDataValue.getDataValue(), 0, DataValuesize);
+  }
+  public static DataValue decode(XdrDataInputStream stream) throws IOException {
+    DataValue decodedDataValue = new DataValue();
+  int DataValuesize = stream.readInt();
+  decodedDataValue.DataValue = new byte[DataValuesize];
+  stream.read(decodedDataValue.DataValue, 0, DataValuesize);
+    return decodedDataValue;
+  }
+}