Nametag mint tx data

src/main/java/com/unicity/sdk/token/Token.java

@@ -44,6 +44,10 @@ public Token(TokenState state, Transaction<T> genesis, List<Transaction<Transfer
     this.nametags = List.copyOf(nametags);
   }
 
+  public Token(TokenState state, Transaction<T> genesis, List<Token<?>> nametags) {
+    this(state, genesis, List.of(), nametags);
+  }
+
   public Token(TokenState state, Transaction<T> genesis) {
     this(state, genesis, List.of(), List.of());
   }

src/main/java/com/unicity/sdk/token/TokenId.java

@@ -7,6 +7,7 @@
 import com.unicity.sdk.util.HexConverter;
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.Objects;
 
 /**
  * Globally unique identifier of a token.
@@ -27,6 +28,8 @@ public BitString toBitString() {
     }
 
     public static TokenId fromNameTag(String name) {
+      Objects.requireNonNull(name, "Name cannot be null");
+
       return new TokenId(
           new DataHasher(HashAlgorithm.SHA256)
               .update(name.getBytes(StandardCharsets.UTF_8))

src/main/java/com/unicity/sdk/transaction/MintTransactionData.java

@@ -12,7 +12,6 @@
 import com.unicity.sdk.token.TokenType;
 import com.unicity.sdk.token.fungible.TokenCoinData;
 import com.unicity.sdk.util.HexConverter;
-import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.Optional;
@@ -56,32 +55,6 @@ public MintTransactionData(
     this.reason = reason;
   }
 
-  public static MintTransactionData<MintTransactionReason> createForNametag(
-      String name,
-      TokenType tokenType,
-      byte[] tokenData,
-      TokenCoinData coinData,
-      Address recipient,
-      byte[] salt,
-      Address targetAddress
-  ) {
-    Objects.requireNonNull(name, "Name cannot be null");
-    Objects.requireNonNull(targetAddress, "Target address cannot be null");
-
-    return new MintTransactionData<>(
-        TokenId.fromNameTag(name),
-        tokenType,
-        tokenData,
-        coinData,
-        recipient,
-        salt,
-        new DataHasher(HashAlgorithm.SHA256)
-            .update(targetAddress.getAddress().getBytes(StandardCharsets.UTF_8))
-            .digest(),
-        null
-    );
-  }
-
   public TokenId getTokenId() {
     return this.tokenId;
   }

src/main/java/com/unicity/sdk/transaction/NametagMintTransactionData.java

@@ -0,0 +1,34 @@
+package com.unicity.sdk.transaction;
+
+import com.unicity.sdk.address.Address;
+import com.unicity.sdk.hash.DataHasher;
+import com.unicity.sdk.hash.HashAlgorithm;
+import com.unicity.sdk.token.TokenId;
+import com.unicity.sdk.token.TokenType;
+import com.unicity.sdk.token.fungible.TokenCoinData;
+import java.nio.charset.StandardCharsets;
+
+public class NametagMintTransactionData<R extends MintTransactionReason> extends MintTransactionData<R> {
+  public NametagMintTransactionData(
+      String name,
+      TokenType tokenType,
+      byte[] tokenData,
+      TokenCoinData coinData,
+      Address recipient,
+      byte[] salt,
+      Address targetAddress
+  ) {
+    super(
+        TokenId.fromNameTag(name),
+        tokenType,
+        tokenData,
+        coinData,
+        recipient,
+        salt,
+        new DataHasher(HashAlgorithm.SHA256)
+            .update(targetAddress.getAddress().getBytes(StandardCharsets.UTF_8))
+            .digest(),
+        null
+    );
+  }
+}

src/main/java/com/unicity/sdk/transaction/TransferCommitment.java

@@ -52,7 +52,7 @@ public Transaction<TransferTransactionData> toTransaction(Token<?> token,
       throw new RuntimeException("Inclusion proof verification failed.");
     }
 
-    if (!inclusionProof.getAuthenticator().isPresent()) {
+    if (inclusionProof.getAuthenticator().isEmpty()) {
       throw new RuntimeException("Authenticator is missing from inclusion proof.");
     }
 

src/test/java/com/unicity/sdk/common/split/BaseTokenSplitTest.java

@@ -0,0 +1,202 @@
+package com.unicity.sdk.common.split;
+
+import static com.unicity.sdk.utils.TestUtils.randomBytes;
+
+import com.unicity.sdk.StateTransitionClient;
+import com.unicity.sdk.address.Address;
+import com.unicity.sdk.address.DirectAddress;
+import com.unicity.sdk.address.ProxyAddress;
+import com.unicity.sdk.api.SubmitCommitmentResponse;
+import com.unicity.sdk.api.SubmitCommitmentStatus;
+import com.unicity.sdk.hash.DataHash;
+import com.unicity.sdk.hash.DataHasher;
+import com.unicity.sdk.hash.HashAlgorithm;
+import com.unicity.sdk.predicate.MaskedPredicate;
+import com.unicity.sdk.signing.SigningService;
+import com.unicity.sdk.token.Token;
+import com.unicity.sdk.token.TokenId;
+import com.unicity.sdk.token.TokenState;
+import com.unicity.sdk.token.TokenType;
+import com.unicity.sdk.token.fungible.CoinId;
+import com.unicity.sdk.token.fungible.TokenCoinData;
+import com.unicity.sdk.transaction.MintCommitment;
+import com.unicity.sdk.transaction.MintTransactionData;
+import com.unicity.sdk.transaction.TransferCommitment;
+import com.unicity.sdk.transaction.split.SplitMintReason;
+import com.unicity.sdk.transaction.split.TokenSplitBuilder;
+import com.unicity.sdk.transaction.split.TokenSplitBuilder.TokenSplit;
+import com.unicity.sdk.util.InclusionProofUtils;
+import com.unicity.sdk.utils.TokenUtils;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public abstract class BaseTokenSplitTest {
+
+  protected StateTransitionClient client;
+
+  @Test
+  void testTokenSplitFullAmounts() throws Exception {
+    byte[] secret = "SECRET".getBytes(StandardCharsets.UTF_8);
+
+    Token<?> token = TokenUtils.mintToken(
+        this.client,
+        secret,
+        new TokenId(randomBytes(32)),
+        new TokenType(randomBytes(32)),
+        randomBytes(32),
+        new TokenCoinData(Map.of(
+            new CoinId("test_eur".getBytes(StandardCharsets.UTF_8)),
+            BigInteger.valueOf(100),
+            new CoinId("test_usd".getBytes(StandardCharsets.UTF_8)),
+            BigInteger.valueOf(100)
+        )),
+        randomBytes(32),
+        randomBytes(32),
+        null
+    );
+
+    String nametag = "my_nametag";
+
+    Token<?> nametagToken = TokenUtils.mintNametagToken(
+        this.client,
+        secret,
+        nametag,
+        // Direct to random address in the beginning
+        DirectAddress.create(DataHash.fromImprint(new byte[34]))
+    );
+
+    TokenSplitBuilder builder = new TokenSplitBuilder();
+    TokenSplit split = builder
+        .createToken(
+            new TokenId(randomBytes(32)),
+            new TokenType(randomBytes(32)),
+            null,
+            new TokenCoinData(Map.of(
+                new CoinId("test_eur".getBytes(StandardCharsets.UTF_8)),
+                BigInteger.valueOf(100)
+            )),
+            ProxyAddress.create(nametag),
+            randomBytes(32),
+            null
+        )
+        .createToken(
+            new TokenId(randomBytes(32)),
+            new TokenType(randomBytes(32)),
+            null,
+            new TokenCoinData(Map.of(
+                new CoinId("test_usd".getBytes(StandardCharsets.UTF_8)),
+                BigInteger.valueOf(100)
+            )),
+            ProxyAddress.create(nametag),
+            randomBytes(32),
+            null
+        )
+        .build(token);
+
+    TransferCommitment burnCommitment = split.createBurnCommitment(
+        randomBytes(32),
+        SigningService.createFromSecret(secret, token.getState().getUnlockPredicate().getNonce())
+    );
+
+    SubmitCommitmentResponse burnCommitmentResponse = this.client
+        .submitCommitment(token, burnCommitment)
+        .get();
+
+    if (burnCommitmentResponse.getStatus() != SubmitCommitmentStatus.SUCCESS) {
+      throw new Exception(String.format("Failed to submit burn commitment: %s",
+          burnCommitmentResponse.getStatus()));
+    }
+
+    List<MintCommitment<MintTransactionData<SplitMintReason>>> mintCommitments = split.createSplitMintCommitments(
+        burnCommitment.toTransaction(
+            token,
+            InclusionProofUtils.waitInclusionProof(this.client, burnCommitment).get()
+        )
+    );
+
+    for (MintCommitment<MintTransactionData<SplitMintReason>> commitment : mintCommitments) {
+      SubmitCommitmentResponse response = this.client
+          .submitCommitment(commitment)
+          .get();
+
+      if (response.getStatus() != SubmitCommitmentStatus.SUCCESS) {
+        throw new Exception(String.format("Failed to submit burn commitment: %s",
+            response.getStatus()));
+      }
+
+      byte[] nonce = randomBytes(32);
+      TokenState state = new TokenState(
+          MaskedPredicate.create(
+              SigningService.createFromSecret(secret, nonce),
+              HashAlgorithm.SHA256,
+              nonce
+          ),
+          null
+      );
+      Address address = state.getUnlockPredicate()
+          .getReference(
+              commitment.getTransactionData().getTokenType()
+          )
+          .toAddress();
+
+      byte[] nametagNonce = randomBytes(32);
+      TokenState nametagTokenState = new TokenState(
+          MaskedPredicate.create(
+              SigningService.createFromSecret(secret, nametagNonce),
+              HashAlgorithm.SHA256,
+              nametagNonce
+          ),
+          address.getAddress().getBytes(StandardCharsets.UTF_8)
+      );
+
+      TransferCommitment nametagCommitment = TransferCommitment.create(
+          nametagToken,
+          nametagTokenState.getUnlockPredicate().getReference(nametagToken.getType()).toAddress(),
+          randomBytes(32),
+          new DataHasher(HashAlgorithm.SHA256)
+              .update(address.getAddress().getBytes(StandardCharsets.UTF_8))
+              .digest(),
+          null,
+          SigningService.createFromSecret(
+              secret,
+              nametagToken.getState().getUnlockPredicate().getNonce()
+          )
+      );
+
+      SubmitCommitmentResponse nametagTransferResponse = this.client
+          .submitCommitment(nametagToken, nametagCommitment)
+          .get();
+      if (nametagTransferResponse.getStatus() != SubmitCommitmentStatus.SUCCESS) {
+        throw new Exception(String.format("Failed to submit nametag transfer commitment: %s",
+            response.getStatus()));
+      }
+
+      nametagToken = this.client.finalizeTransaction(
+          nametagToken,
+          nametagTokenState,
+          nametagCommitment.toTransaction(
+              nametagToken,
+              InclusionProofUtils.waitInclusionProof(this.client, nametagCommitment).get()
+          )
+      );
+
+      Token<MintTransactionData<SplitMintReason>> splitToken = new Token<>(
+          state,
+          commitment.toTransaction(
+              InclusionProofUtils.waitInclusionProof(this.client, commitment).get()
+          ),
+          List.of(nametagToken)
+      );
+
+      Assertions.assertTrue(splitToken.verify().isSuccessful());
+    }
+
+
+  }
+
+
+}

src/test/java/com/unicity/sdk/e2e/CommonTestFlow.java

@@ -25,6 +25,7 @@
 import com.unicity.sdk.token.TokenType;
 import com.unicity.sdk.token.fungible.CoinId;
 import com.unicity.sdk.transaction.MintTransactionReason;
+import com.unicity.sdk.transaction.NametagMintTransactionData;
 import com.unicity.sdk.transaction.split.SplitMintReason;
 import com.unicity.sdk.token.fungible.TokenCoinData;
 import com.unicity.sdk.transaction.InclusionProof;
@@ -166,7 +167,7 @@ public static void testTransferFlow(StateTransitionClient client) throws Excepti
     DirectAddress bobNametagAddress = bobNametagPredicate.getReference(bobNametagTokenType)
         .toAddress();
     MintCommitment<?> nametagMintCommitment = MintCommitment.create(
-        MintTransactionData.createForNametag(
+        new NametagMintTransactionData<>(
             bobNameTag,
             bobNametagTokenType,
             new byte[10],

src/test/java/com/unicity/sdk/functional/FunctionalTokenSplitTest.java

@@ -0,0 +1,13 @@
+package com.unicity.sdk.functional;
+
+import com.unicity.sdk.StateTransitionClient;
+import com.unicity.sdk.TestAggregatorClient;
+import com.unicity.sdk.common.split.BaseTokenSplitTest;
+import org.junit.jupiter.api.BeforeEach;
+
+public class FunctionalTokenSplitTest extends BaseTokenSplitTest {
+  @BeforeEach
+  void setUp() {
+    this.client = new StateTransitionClient(new TestAggregatorClient());
+  }
+}

src/test/java/com/unicity/sdk/token/TokenTest.java

@@ -11,6 +11,7 @@
 import com.unicity.sdk.token.fungible.TokenCoinData;
 import com.unicity.sdk.transaction.InclusionProof;
 import com.unicity.sdk.transaction.MintTransactionData;
+import com.unicity.sdk.transaction.NametagMintTransactionData;
 import com.unicity.sdk.transaction.Transaction;
 import com.unicity.sdk.transaction.TransferTransactionData;
 import com.unicity.sdk.utils.TestUtils;
@@ -47,7 +48,7 @@ public void testJsonSerialization() throws IOException {
             nametagNonce),
         DirectAddress.create(new DataHash(HashAlgorithm.SHA256, TestUtils.randomBytes(32)))
     );
-    MintTransactionData<?> nametagGenesisData = MintTransactionData.createForNametag(
+    MintTransactionData<?> nametagGenesisData = new NametagMintTransactionData<>(
         UUID.randomUUID().toString(),
         new TokenType(TestUtils.randomBytes(32)),
         TestUtils.randomBytes(5),