How to properly make NonFungibleToken's Unique - corda

Question

Question:
Does the TokenIdentifier of a TokenType used to build a NonFungibleToken have to be a unique string?
Long-Winded Background:
The documentation clearly outlines that “It is, in fact, the responsibility of the developer to ensure that no two instances of an NonFungibleToken refer to the same off-chain or on-chain object…”
I was under the impression that the UniqueIdentifier was how I ensured that uniqueness:
TokenType tokenType = new TokenType("Toyota Corolla", 0);
IssuedTokenType issuedTokenType = new IssuedTokenType(partyA, tokenType);
String VIN = "1G2JB12F047226515";
UUID uuid = UUID.randomUUID();
UniqueIdentifier uniqueIdentifier = new UniqueIdentifier(VIN, uuid);
NonFungibleToken nonFungibleToken = new NonFungibleToken(issuedTokenType, partyA, uniqueIdentifier);
This allows me to define limitless Toyota Corolla’s each with their own unique UUID and Vehicle Identification Number (VIN).
The MoveNonFungibleTokens() flow allows me to specify a QueryCriteria to isolate the specific NonFungibleToken I wish to move (I use a LinearStateQueryCriteria specifying the UUID):
subFlow(new MoveNonFungibleTokens(partyAndToken, observers, queryCriteria));
However when I want to redeem a NonFungibleToken the RedeemNonFungibleTokens() flow only allows me to specify a TokenType:
subFlow(new RedeemNonFungibleTokens(tokenType, issuer, observers));
This means I can’t identify a NonFungibleToken by its UUID. If you do what I am doing above you will receive the following error when I try to redeem:
Exactly one held token of a particular type TokenType(tokenIdentifier=' Toyota Corolla ', fractionDigits=0) should be in the vault at any one time.
If this is the case then TokenType’s tokenIndentifier ("Toyota Corolla") must be the source of uniqueness. I would have to do something like this:
TokenType tokenType = new TokenType("Toyota Corolla-" + UUID.randomUUID(), 0);
Is this correct or have I missed something?
I was just really surprised when I started writing the Redeem parts of my token tests and thought “Well then what is the purpose of the UniqueIdentifier in a NonFungibleToken?”

Answer 1

In the case of non-fungible tokens, the relationship between the token type and the token is one to one; that's why the redeem flow takes only the TokenType parameter.
Looking at the MoveNonFungibleTokens flow input parameters here, they sort of contradict the first statement; because even the comment on the flow states that it should be used for one TokenType at a time, which means the queryCriteria parameter is not needed since you're already specifying the token (token type) that you want to move inside the PartyAndToken parameter. I will forward this discussion to R3 engineers to get a clarification.
As for the your question, the reason you need the unique identifier in the non-fungible token is because it extends LinearState (which is identified by that UUID).
Remember that states are immutable in Corda, so how do you mimic an update? You do it buy using a LinearState, for instance if your non-fungible token is a car and you want to change the owner of the car (i.e. update the holder of the token); then you create a transaction where the input is the current token and the output is the updated token which should have the same linearId as the input; this way the output and the input are tied together and now you can track the history of updates of a certain state by querying that shared linearId.
Side note: Your LinearState should have 2 constructors; one that assigns a random linearId and you should use it when creating a new state, and another constructor that takes a linearId as an input parameter; this constructor should be used when you create the output of an update transaction (so you can create the output with the linearId of the input), also you must mark that constructor with the #CordaSerializable annotation so that Corda uses it when it check-points a certain flow (i.e. serializes then de-serializes your state) otherwise Corda will use the other constructor and assign a new random value for your linearId when it de-serializes your state (when the flow resumes) and you essentially end with a different state!
I recommend that you use EvolvableTokenType for your car example instead of TokenType; this would allow you to add your custom attributes (VIN, price, mileage, etc...) and you can can control which attributes can be updated (price, mileage) and which cannot (VIN); see more about that in the official free Corda course from R3 here.