$> program --read-inline '{"Type": "Burn", "TokenId": "0x..."}' 
$> program --read-inline '[{"Type": "Mint", "TokenId": "0x...", "Address": "0x..."}, {"Type": "Burn", "TokenId": "0x..."}]'

$> program --read-file transactions.json

$> program --wallet 0x...

{ 
  "Type": "Mint", 
  "TokenId": string, 
  "Address": string 
}

{ 
  "Type": "Burn", 
  "TokenId": string 
}

{ 
  "Type": "Transfer", 
  "TokenId": string, 
  "From": string, 
  "To": string 
}

[
    {
        "Type": "Mint",
        "TokenId": "0xA000000000000000000000000000000000000000",
        "Address": "0x1000000000000000000000000000000000000000"
    },
    {
        "Type": "Mint",
        "TokenId": "0xB000000000000000000000000000000000000000",
        "Address": "0x2000000000000000000000000000000000000000"
    },
    {
        "Type": "Mint",
        "TokenId": "0xC000000000000000000000000000000000000000",
        "Address": "0x3000000000000000000000000000000000000000"
    },
    {
        "Type": "Burn",
        "TokenId": "0xA000000000000000000000000000000000000000"
    },
    {
        "Type": "Transfer",
        "TokenId": "0xB000000000000000000000000000000000000000",
        "From": "0x2000000000000000000000000000000000000000",
        "To": "0x3000000000000000000000000000000000000000"
    }
]

public class Transaction
{
 // Transaction type: Mint, Burn, Transfer, etc. 
 // As a type, we may use enum here as well.
 [JsonProperty("Type", Required = Required.Always)]
 public string Type { get; set; }

 [JsonProperty("TokenId", Required = Required.Always)]
 public string TokenId { get; set; }

 // Address of the Wallet to own Token Id created (Minted)
 [JsonProperty("Address", Required = Required.Default)]
 public string Address { get; set; }

 // From Address of the Transfer operation.
 [JsonProperty("From", Required = Required.Default)]
 public string From { get; set; }

 // To Address of the Transfer operation.
 [JsonProperty("To", Required = Required.Default)]
 public string To { get; set; }
}

public class OwnershipInfo
{
 [XmlElement("WalletAddress")]
 public string WalletAddress { get; set; }

 [XmlElement("Timestamp")]
 public DateTime Timestamp {  get; set; }
}

public class TokenStorage
{
 // To easily find owning wallet by NFT token.
 public Dictionary<string, string> NftTokenWalletMap { get; set; }
}

public async Task<string> FindWalletOwnerAsync(string tokenId)
{
 if (_tokenStorage.NftTokenWalletMap.ContainsKey(tokenId))
 {
  return await Task<string>.FromResult(_tokenStorage.NftTokenWalletMap[tokenId]);
 }

 return null;
}

public class TokenStorage
{
 // To easily find list of owned Tokens in the wallet.
 public Dictionary<string, List<string>> WalletNftTokensMap { get; set; }
}

public async Task<List<string>> GetTokensAsync(string walletId)
{
 var result = new List<string>();

 if (_tokenStorage.WalletNftTokensMap.ContainsKey(walletId) &&
  _tokenStorage.WalletNftTokensMap[walletId] != null)
 {
  result = _tokenStorage.WalletNftTokensMap[walletId];

  result.Sort();
 }

 return await Task.FromResult(result);
}

public class TokenStorage
{
 // To easily change the ownership.
 public Dictionary<string, NFTToken> NftTokenOwnershipMap { get; set; }
}

public class NFTToken
{
 public string TokenId { get; set; }

 /// <summary>
 /// Allows to efficiently insert new owners.
 /// </summary>
 public LinkedList<OwnershipInfo> OwnershipInfo { get; set; }
}

private bool MintNFTToken(string tokenId, string walletAddress)
{
 // Is token really new/unique?
 if (!_tokenStorage.NftTokenWalletMap.ContainsKey(tokenId))
 {
  // Do we know such wallet address?
  if (!_tokenStorage.WalletNftTokensMap.ContainsKey(walletAddress))
  {
   // Remember a new wallet address.
   _tokenStorage.WalletNftTokensMap.Add(walletAddress, new List<string>());
  }
  
  // Add token to the wallet to Wallet-Token records.
  _tokenStorage.WalletNftTokensMap[walletAddress].Add(tokenId);
  
  // Add Token-Wallet record.
  _tokenStorage.NftTokenWalletMap.Add(tokenId, walletAddress);

  // Create an Ownership entry in history
  var nftToken = new NFTToken
  {
   TokenId = tokenId,
   OwnershipInfo = new LinkedList<OwnershipInfo>()
  };

  // Insert the record
  nftToken.OwnershipInfo.AddFirst(
   new OwnershipInfo
   {
    WalletAddress = walletAddress,
    Timestamp = DateTime.Now
   });
  _tokenStorage.NftTokenOwnershipMap.Add(tokenId, nftToken);

  return true;
 }

 return false;
}

private void BurnNFTToken(string tokenId)
{
 if (_tokenStorage.NftTokenWalletMap.ContainsKey(tokenId))
 {
  string walletId = _tokenStorage.NftTokenWalletMap[tokenId];

  _tokenStorage.NftTokenWalletMap.Remove(tokenId);

  if (_tokenStorage.WalletNftTokensMap.ContainsKey(walletId))
  {
   _tokenStorage.WalletNftTokensMap.Remove(walletId);
  }
 }

 if (_tokenStorage.NftTokenOwnershipMap.ContainsKey(tokenId))
 {
  _tokenStorage.NftTokenOwnershipMap.Remove(tokenId);
 }
}

private bool ChangeOwnership(string tokenId, string oldWalletAddress, string newWalletAddress)
{
 // Validate that token is actually owned by From
 if (_tokenStorage.NftTokenWalletMap.ContainsKey(tokenId) &&
  _tokenStorage.NftTokenWalletMap[tokenId].Equals(oldWalletAddress))
 {
  // Remove existing Wallet-Token record, it's not valid anymore.
  _tokenStorage.WalletNftTokensMap[oldWalletAddress].Remove(tokenId);
  // Add a new one.
  if (!_tokenStorage.WalletNftTokensMap.ContainsKey(newWalletAddress))
  {
   _tokenStorage.WalletNftTokensMap.Add(newWalletAddress, new List<string>());
  }
  _tokenStorage.WalletNftTokensMap[newWalletAddress].Add(tokenId);

  // Update a second map that maps back Token to Wallet.
  _tokenStorage.NftTokenWalletMap[tokenId] = newWalletAddress;

  // Now, create a new ownership history record.
  NFTToken nftToken = _tokenStorage.NftTokenOwnershipMap[tokenId];
  nftToken.OwnershipInfo.AddFirst(
   new OwnershipInfo
   {
    WalletAddress = newWalletAddress,
    Timestamp = DateTime.Now
   });

  return true;
 }

 return false;
}

public class TokenStorage
{
 public TokenStorage()
 {
  NftTokenWalletMap = new Dictionary<string, string>();
  WalletNftTokensMap = new Dictionary<string, List<string>>();
  NftTokenOwnershipMap = new Dictionary<string, NFTToken>();
 }

 // To easily find owning wallet by NFT token.
 public Dictionary<string, string> NftTokenWalletMap { get; set; }

 // To easily find list of owned Tokens in the wallet.
 public Dictionary<string, List<string>> WalletNftTokensMap { get; set; }

 // To easily change the ownership.
 public Dictionary<string, NFTToken> NftTokenOwnershipMap { get; set; }
}

public class NFTToken
{
 public string TokenId { get; set; }

 /// <summary>
 /// Allows to efficiently insert new owners.
 /// </summary>
 public LinkedList<OwnershipInfo> OwnershipInfo { get; set; }
}

class Program
{
    static async Task<int> Main(string[] args)
    {
        var root = new RootCommand();
        root.Description = "Wallet CLI app to work with NFT tokens.";

        root.AddCommand(new ReadFileCommand());
        root.AddCommand(new ReadInlineCommand());
        root.AddCommand(new WalletCommand());
        root.AddCommand(new ResetCommand());
        root.AddCommand(new NftCommand());

        root.Handler = CommandHandler.Create(() => root.Invoke(args));

        return await new CommandLineBuilder(root)
           .UseHost(_ => Host.CreateDefaultBuilder(args), builder => builder
                .ConfigureServices(RegisterServices)
                .UseCommandHandler<ReadFileCommand, ReadFileCommandHandler>()
                .UseCommandHandler<ReadInlineCommand, ReadInlineCommandHandler>()
                .UseCommandHandler<WalletCommand, WalletCommandHandler>()
                .UseCommandHandler<ResetCommand, ResetCommandHandler>()
                .UseCommandHandler<NftCommand, NftCommandHandler>())
           .UseDefaults()
           .Build()
           .InvokeAsync(args);
    }

    private static void RegisterServices(IServiceCollection services)
    {
        services.AddHttpClient();
        services.AddSingleton<IFileSystem, XmlFileSystem>();
        services.AddSingleton<ITransactionsManager, TransactionsManager>();
        services.AddSingleton<IConsoleOutputHandlers, ConsoleOutputHandlers>();
    }
}

>nft.app.exe -h
Description:
  Wallet CLI app to work with NFT tokens.

Usage:
  Nft.App [command] [options]

Options:
  --version       Show version information
  -?, -h, --help  Show help and usage information

Commands:
  --read-file <filePath>  Reads transactions from the ?le in the speci?ed location.
  --read-inline <json>    Reads either a single json element, or an array of json elements representing transactions as
                          an argument.
  --wallet <Address>      Lists all NFTs currently owned by the wallet of the given address.
  --reset                 Deletes all data previously processed by the program.
  --nft <tokenId>         Returns ownership information for the nft with the given id.

>Nft.App --read-file transactions.json