Token symbol of MultiToken Contract will be case-insensitive

contract/AElf.Contracts.MultiToken/TokenContractState.cs

@@ -9,6 +9,7 @@ public partial class TokenContractState : ContractState
 
     public StringState ChainPrimaryTokenSymbol { get; set; }
     public MappedState<string, TokenInfo> TokenInfos { get; set; }
+    public MappedState<string, bool> InsensitiveTokenExisting { get; set; }
     public MappedState<string, string> SymbolSeedMap { get; set; }
     public MappedState<Address, string, long> Balances { get; set; }
     public MappedState<Address, Address, string, long> Allowances { get; set; }

contract/AElf.Contracts.MultiToken/TokenContract_Actions.cs

@@ -56,7 +56,7 @@
             if (!IsAddressInCreateWhiteList(Context.Sender) &&
                 input.Symbol != TokenContractConstants.SeedCollectionSymbol)
             {
-                var symbolSeed = State.SymbolSeedMap[input.Symbol];
+                var symbolSeed = State.SymbolSeedMap[input.Symbol.ToUpper()];
                 CheckSeedNFT(symbolSeed, input.Symbol);
                 // seed nft for one-time use only
                 long balance = State.Balances[Context.Sender][symbolSeed];

contract/AElf.Contracts.MultiToken/TokenContract_Helper.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Text.RegularExpressions;
 using AElf.Contracts.Parliament;
 using AElf.CSharp.Core;
 using AElf.Sdk.CSharp;
@@ -14,20 +15,19 @@
 
 public partial class TokenContract
 {
-    private static bool IsValidSymbolChar(char character)
+    private static bool IsValidSymbol(string symbol)
     {
-        return (character >= 'A' && character <= 'Z') || (character >= '0' && character <= '9') ||
-               character == TokenContractConstants.NFTSymbolSeparator;
+        return Regex.IsMatch(symbol, "^[a-zA-Z0-9]+(-[0-9]+)?$");
     }
 
-    private bool IsValidItemIdChar(char character)
+    private bool IsValidItemId(string symbolItemId)
     {
-        return character >= '0' && character <= '9';
+        return Regex.IsMatch(symbolItemId, "^[0-9]+$");
     }
 
-    private bool IsValidCreateSymbolChar(char character)
+    private bool IsValidCreateSymbol(string symbol)
     {
-        return character >= 'A' && character <= 'Z';
+        return Regex.IsMatch(symbol, "^[a-zA-Z0-9]+$");
     }
 
     private TokenInfo AssertValidToken(string symbol, long amount)
@@ -40,7 +40,7 @@
 
     private void AssertValidSymbolAndAmount(string symbol, long amount)
     {
-        Assert(!string.IsNullOrEmpty(symbol) && symbol.All(IsValidSymbolChar),
+        Assert(!string.IsNullOrEmpty(symbol) && IsValidSymbol(symbol),
             "Invalid symbol.");
         Assert(amount > 0, "Invalid amount.");
     }
@@ -184,13 +184,14 @@
     private void RegisterTokenInfo(TokenInfo tokenInfo)
     {
         CheckTokenExists(tokenInfo.Symbol);
-        Assert(!string.IsNullOrEmpty(tokenInfo.Symbol) && tokenInfo.Symbol.All(IsValidSymbolChar),
+        Assert(!string.IsNullOrEmpty(tokenInfo.Symbol) && IsValidSymbol(tokenInfo.Symbol),
             "Invalid symbol.");
         Assert(!string.IsNullOrEmpty(tokenInfo.TokenName), "Token name can neither be null nor empty.");
         Assert(tokenInfo.TotalSupply > 0, "Invalid total supply.");
         Assert(tokenInfo.Issuer != null, "Invalid issuer address.");
         Assert(tokenInfo.Owner != null, "Invalid owner address.");
         State.TokenInfos[tokenInfo.Symbol] = tokenInfo;
+        State.InsensitiveTokenExisting[tokenInfo.Symbol.ToUpper()] = true;
     }
 
     private void CrossChainVerify(Hash transactionId, long parentChainHeight, int chainId, MerklePath merklePath)
@@ -255,8 +256,11 @@
     private void CheckTokenExists(string symbol)
     {
         var empty = new TokenInfo();
-        var existing = State.TokenInfos[symbol];
+        // check old token
+        var existing = State.TokenInfos[symbol.ToUpper()];
         Assert(existing == null || existing.Equals(empty), "Token already exists.");
+        // check new token
+        Assert(!State.InsensitiveTokenExisting[symbol.ToUpper()], "Token already exists.");
     }
 
     private void CheckSymbolLength(string symbol, SymbolType symbolType)

contract/AElf.Contracts.MultiToken/TokenContract_NFTHelper.cs

@@ -7,9 +7,9 @@ public partial class TokenContract
     private SymbolType GetCreateInputSymbolType(string symbol)
     {
         var words = symbol.Split(TokenContractConstants.NFTSymbolSeparator);
-        Assert(words[0].Length > 0 && words[0].All(IsValidCreateSymbolChar), "Invalid Symbol input");
+        Assert(words[0].Length > 0 && IsValidCreateSymbol(words[0]), "Invalid Symbol input");
         if (words.Length == 1) return SymbolType.Token;
-        Assert(words.Length == 2 && words[1].Length > 0 && words[1].All(IsValidItemIdChar), "Invalid NFT Symbol input");
+        Assert(words.Length == 2 && words[1].Length > 0 && IsValidItemId(words[1]), "Invalid NFT Symbol input");
         return words[1] == TokenContractConstants.CollectionSymbolSuffix ? SymbolType.NftCollection : SymbolType.Nft;
     }
 

contract/AElf.Contracts.MultiToken/TokenContract_NFT_Actions.cs

@@ -48,15 +48,15 @@
             CheckSymbolLength(ownedSymbol, ownedSymbolType);
             CheckTokenAndCollectionExists(ownedSymbol);
             CheckSymbolSeed(ownedSymbol);
-            State.SymbolSeedMap[ownedSymbol] = input.Symbol;
+            State.SymbolSeedMap[ownedSymbol.ToUpper()] = input.Symbol;
         }
 
         return CreateToken(input, SymbolType.Nft);
     }
 
     private void CheckSymbolSeed(string ownedSymbol)
     {
-        var oldSymbolSeed = State.SymbolSeedMap[ownedSymbol];
+        var oldSymbolSeed = State.SymbolSeedMap[ownedSymbol.ToUpper()];
 
         Assert(oldSymbolSeed == null || !State.TokenInfos[oldSymbolSeed].ExternalInfo.Value
                    .TryGetValue(TokenContractConstants.SeedExpireTimeExternalInfoKey,
@@ -102,7 +102,7 @@
         var words = symbol.Split(TokenContractConstants.NFTSymbolSeparator);
         const int tokenSymbolLength = 1;
         if (words.Length == tokenSymbolLength) return null;
-        Assert(words.Length == 2 && words[1].All(IsValidItemIdChar), "Invalid NFT Symbol Input");
+        Assert(words.Length == 2 && IsValidItemId(words[1]), "Invalid NFT Symbol Input");
         return symbol == $"{words[0]}-0" ? null : $"{words[0]}-0";
     }
 

contract/AElf.Contracts.TokenConverter/TokenConverterContract.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Globalization;
 using System.Linq;
+using System.Text.RegularExpressions;
 using AElf.Contracts.MultiToken;
 using AElf.CSharp.Core;
 using AElf.Sdk.CSharp;
@@ -321,8 +322,7 @@
 
     private static bool IsValidSymbol(string symbol)
     {
-        return symbol.Length > 0 &&
-               symbol.All(c => c >= 'A' && c <= 'Z');
+        return Regex.IsMatch(symbol, "^[a-zA-Z0-9]+$");
     }
 
     private static bool IsValidBaseSymbol(string symbol)

src/AElf.CSharp.CodeOps/Validators/Whitelist/IWhitelistProvider.cs

@@ -4,6 +4,7 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Text;
+using System.Text.RegularExpressions;
 using AElf.Cryptography.SecretSharing;
 using AElf.CSharp.Core;
 using AElf.Kernel.SmartContract;
@@ -37,6 +38,7 @@
             .Assembly(System.Reflection.Assembly.Load("System.Runtime.Extensions"), Trust.Partial)
             .Assembly(System.Reflection.Assembly.Load("System.Private.CoreLib"), Trust.Partial)
             .Assembly(System.Reflection.Assembly.Load("System.ObjectModel"), Trust.Partial)
+            .Assembly(System.Reflection.Assembly.Load("System.Text.RegularExpressions"), Trust.Partial)
             .Assembly(System.Reflection.Assembly.Load("System.Linq"), Trust.Full)
             .Assembly(System.Reflection.Assembly.Load("System.Linq.Expressions"), Trust.Full)
             .Assembly(System.Reflection.Assembly.Load("System.Collections"), Trust.Full)
@@ -142,6 +144,17 @@
                     .Member(nameof(Encoding.UTF8), Permission.Allowed)
                     .Member(nameof(Encoding.UTF8.GetByteCount), Permission.Allowed)))
             .Namespace("System.Numerics", Permission.Allowed)
+            .Namespace("System.Text.RegularExpressions", Permission.Denied, type => type
+                .Type(nameof(Regex), Permission.Denied, member => member
+                    .Member(nameof(Regex.IsMatch), Permission.Allowed)
+                    .Member(nameof(Regex.Match), Permission.Allowed)
+                    .Member(nameof(Regex.Matches), Permission.Allowed)
+                    .Member(nameof(Regex.Replace), Permission.Allowed)
+                    .Member(nameof(Regex.Split), Permission.Allowed)
+                )
+                .Type(nameof(MatchCollection), Permission.Allowed)
+                .Type(nameof(Match), Permission.Allowed)
+            )
             ;
     }
 

test/AElf.Contracts.MultiToken.Tests/BVT/NftApplicationTests.cs

@@ -275,8 +275,23 @@ public async Task MultiTokenContract_Create_NFTCollection_Input_Check_Test()
                 ExternalInfo = input.ExternalInfo,
                 Owner = input.Owner
             });
-
-            var result = await TokenContractStub.Create.SendWithExceptionAsync(seedInput);;
+
+            var result = await TokenContractStub.Create.SendAsync(seedInput);
+            result.TransactionResult.Status.ShouldBe(TransactionResultStatus.Mined);
+
+            seedInput = BuildSeedCreateInput(new CreateInput
+            {
+                Symbol = "ABC123()",
+                TokenName = input.TokenName,
+                TotalSupply = input.TotalSupply,
+                Decimals = input.Decimals,
+                Issuer = input.Issuer,
+                IssueChainId = input.IssueChainId,
+                ExternalInfo = input.ExternalInfo,
+                Owner = input.Owner
+            });
+
+            result = await TokenContractStub.Create.SendWithExceptionAsync(seedInput);
             result.TransactionResult.Status.ShouldBe(TransactionResultStatus.Failed);
             result.TransactionResult.Error.ShouldContain("Invalid Symbol input");
         }

test/AElf.Contracts.MultiToken.Tests/BVT/SymbolValidationTest.cs

@@ -0,0 +1,23 @@
+using System.Text.RegularExpressions;
+using Shouldly;
+using Xunit;
+
+namespace AElf.Contracts.MultiToken;
+
+public class SymbolValidationTest
+{
+    private const string RegexPattern = "^[a-zA-Z0-9]+(-[0-9]+)?$";
+
+    [Theory]
+    [InlineData("ELF", true)]
+    [InlineData("ELF-", false)]
+    [InlineData("ABC-123", true)]
+    [InlineData("abc-1", true)]
+    [InlineData("ABC-ABC", false)]
+    [InlineData("ABC--", false)]
+    [InlineData("121-1", true)]
+    public void SymbolValidation(string symbol, bool isValid)
+    {
+        Regex.IsMatch(symbol, RegexPattern).ShouldBe(isValid);
+    }
+}

test/AElf.Contracts.TokenConverter.Tests/TokenConvertConnectorTest.cs

@@ -87,7 +87,7 @@ await ExecuteProposalForParliamentTransaction(TokenConverterContractAddress,
     [Theory]
     [InlineData("WRITE", "0.5", "0.5", "resource token symbol has existed")]
     [InlineData("", "0.5", "0.5", "resource token symbol should not be empty")]
-    [InlineData("N89", "0.2", "0.5", "Invalid symbol.")]
+    [InlineData("N89()", "0.2", "0.5", "Invalid symbol.")]
     [InlineData("MKA", "0", "0.5", "Connector Shares has to be a decimal between 0 and 1.")]
     [InlineData("JUN", "0.9", "1", "Connector Shares has to be a decimal between 0 and 1.")]
     public async Task AddPairConnector_With_Invalid_Input_Test(string tokenSymbol, string resourceWeight,

test/AElf.Contracts.TokenConverter.Tests/TokenConverterContractTests.cs

@@ -84,7 +84,7 @@ public async Task Initialize_Failed_Test()
         //Base token symbol is invalid.
         {
             var input = GetLegalInitializeInput();
-            input.BaseTokenSymbol = "elf1";
+            input.BaseTokenSymbol = "elf1<>";
             var result = (await DefaultStub.Initialize.SendWithExceptionAsync(input)).TransactionResult;
             result.Status.ShouldBe(TransactionResultStatus.Failed);
             result.Error.Contains("Base token symbol is invalid.").ShouldBeTrue();
@@ -111,7 +111,7 @@ public async Task Initialize_Failed_Test()
         //Invalid connector symbol
         {
             var input = GetLegalInitializeInput();
-            input.Connectors[0].Symbol = "write";
+            input.Connectors[0].Symbol = "write-0";
             var result = (await DefaultStub.Initialize.SendWithExceptionAsync(input)).TransactionResult;
             result.Status.ShouldBe(TransactionResultStatus.Failed);
             result.Error.Contains("Invalid symbol.").ShouldBeTrue();