Merge branch 'master' into Fix/profile-balance-amount

Author: andygruening

Assets/SequenceSDK/Utils/Tests/DecimalNormalizerTests.cs

@@ -0,0 +1,209 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Numerics;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using Sequence.Utils;
+
+public class DecimalNormalizerTests
+{
+    [Test]
+    public void Normalize_WithDefaultDecimals_ReturnsCorrectString()
+    {
+        string result = DecimalNormalizer.Normalize(1.5f);
+        Assert.AreEqual("1500000000000000000", result);
+    }
+
+    [Test]
+    public void Normalize_WithCustomDecimals_ReturnsCorrectString()
+    {
+        string result = DecimalNormalizer.Normalize(1.5f, 6);
+        Assert.AreEqual("1500000", result);
+    }
+
+    [Test]
+    public void Normalize_WithZero_ReturnsZero()
+    {
+        string result = DecimalNormalizer.Normalize(0f);
+        Assert.AreEqual("0", result);
+    }
+
+    [Test]
+    public void Normalize_WithNegativeNumber_ReturnsPositiveResult()
+    {
+        string result = DecimalNormalizer.Normalize(-1.5f, 6);
+        Assert.AreEqual("1500000", result);
+    }
+
+    [Test]
+    public void NormalizeAsBigInteger_WithDefaultDecimals_ReturnsCorrectBigInteger()
+    {
+        BigInteger result = DecimalNormalizer.NormalizeAsBigInteger(1.5f);
+        BigInteger expected = new BigInteger(1500000000000000000);
+        Assert.AreEqual(expected, result);
+    }
+
+    [Test]
+    public void NormalizeAsBigInteger_WithCustomDecimals_ReturnsCorrectBigInteger()
+    {
+        BigInteger result = DecimalNormalizer.NormalizeAsBigInteger(2.75f, 4);
+        BigInteger expected = new BigInteger(27500);
+        Assert.AreEqual(expected, result);
+    }
+
+    [Test]
+    public void NormalizeAsBigInteger_WithSmallNumber_ReturnsCorrectBigInteger()
+    {
+        BigInteger result = DecimalNormalizer.NormalizeAsBigInteger(0.001f, 6);
+        BigInteger expected = new BigInteger(1000);
+        Assert.AreEqual(expected, result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithWholeNumber_ReturnsCorrectString()
+    {
+        BigInteger input = new BigInteger(1500000000000000000);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 18);
+        Assert.AreEqual("1.5", result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithCustomDecimals_ReturnsCorrectString()
+    {
+        BigInteger input = new BigInteger(1500000);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 6);
+        Assert.AreEqual("1.5", result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithSmallNumber_ReturnsCorrectString()
+    {
+        BigInteger input = new BigInteger(1000);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 6);
+        Assert.AreEqual("0.001", result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithZero_ReturnsZero()
+    {
+        BigInteger input = new BigInteger(0);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 18);
+        Assert.AreEqual("0", result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithNegativeNumber_ReturnsPositiveResult()
+    {
+        BigInteger input = new BigInteger(-1500000000000000000);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 18);
+        Assert.AreEqual("1.5", result);
+    }
+
+    [Test]
+    public void ReturnToNormalString_WithTrailingZeros_TrimsZeros()
+    {
+        BigInteger input = new BigInteger(1500000000000000000);
+        string result = DecimalNormalizer.ReturnToNormalString(input, 18);
+        Assert.AreEqual("1.5", result);
+    }
+
+    [Test]
+    public void ReturnToNormal_WithBigInteger_ReturnsCorrectFloat()
+    {
+        BigInteger input = new BigInteger(1500000000000000000);
+        float result = DecimalNormalizer.ReturnToNormal(input, 18);
+        Assert.AreEqual(1.5f, result, 0.0001f);
+    }
+
+    [Test]
+    public void ReturnToNormal_WithCustomDecimals_ReturnsCorrectFloat()
+    {
+        BigInteger input = new BigInteger(2750000);
+        float result = DecimalNormalizer.ReturnToNormal(input, 6);
+        Assert.AreEqual(2.75f, result, 0.0001f);
+    }
+
+    [Test]
+    public void ReturnToNormalPrecise_WithBigInteger_ReturnsCorrectDecimal()
+    {
+        BigInteger input = new BigInteger(1500000000000000000);
+        decimal result = DecimalNormalizer.ReturnToNormalPrecise(input, 18);
+        Assert.AreEqual(1.5m, result);
+    }
+
+    [Test]
+    public void ReturnToNormalPrecise_WithCustomDecimals_ReturnsCorrectDecimal()
+    {
+        BigInteger input = new BigInteger(3250000);
+        decimal result = DecimalNormalizer.ReturnToNormalPrecise(input, 6);
+        Assert.AreEqual(3.25m, result);
+    }
+
+    [Test]
+    public void RoundTrip_NormalizeAndReturnToNormal_PreservesValue()
+    {
+        float originalValue = 12.34f;
+        int decimals = 6;
+        
+        BigInteger normalized = DecimalNormalizer.NormalizeAsBigInteger(originalValue, decimals);
+        float returned = DecimalNormalizer.ReturnToNormal(normalized, decimals);
+        
+        Assert.AreEqual(originalValue, returned, 0.0001f);
+    }
+
+    [Test]
+    public void EdgeCase_VerySmallNumber_HandlesCorrectly()
+    {
+        float verySmall = 0.000001f;
+        int decimals = 18;
+        
+        string normalized = DecimalNormalizer.Normalize(verySmall, decimals);
+        BigInteger bigInt = BigInteger.Parse(normalized);
+        float returned = DecimalNormalizer.ReturnToNormal(bigInt, decimals);
+        
+        Assert.AreEqual(verySmall, returned, 0.0000001f);
+    }
+
+    [Test]
+    public void EdgeCase_LargeNumber_HandlesCorrectly()
+    {
+        float largeNumber = 9999.99f;
+        int decimals = 6;
+        
+        BigInteger normalized = DecimalNormalizer.NormalizeAsBigInteger(largeNumber, decimals);
+        float returned = DecimalNormalizer.ReturnToNormal(normalized, decimals);
+        
+        Assert.AreEqual(largeNumber, returned, 0.01f);
+    }
+
+    [Test]
+    public void BugReproTest_String()
+    {
+        BigInteger input = BigInteger.Parse("10000000000000000000000000");
+        
+        string result = DecimalNormalizer.ReturnToNormalString(input, 18);
+        
+        Assert.AreEqual("10000000", result);
+    }
+
+    [Test]
+    public void BugReproTest_Float()
+    {
+        BigInteger input = BigInteger.Parse("10000000000000000000000000");
+        
+        float result = DecimalNormalizer.ReturnToNormal(input, 18);
+        
+        Assert.AreEqual(10000000f, result);
+    }
+
+    [Test]
+    public void BugReproTest_Decimal()
+    {
+        BigInteger input = BigInteger.Parse("10000000000000000000000000");
+        
+        decimal result = DecimalNormalizer.ReturnToNormalPrecise(input, 18);
+        
+        Assert.AreEqual(decimal.Parse("10000000"), result);
+    }
+}

Assets/SequenceSDK/Utils/Tests/DecimalNormalizerTests.cs.meta

@@ -0,0 +1,23 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using NUnit.Framework;
+using Sequence.EmbeddedWallet;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Sequence.WaaS.Tests
+{
+    public class SequenceLoginTests 
+    {
+        [Test]
+        public void TestSetConnectedWalletAddressNull()
+        {
+            LogAssert.Expect(LogType.Error, "The connected wallet address cannot be null or empty.");
+
+            Assert.Throws<ArgumentNullException>(
+                () => SequenceLogin.GetInstance().SetConnectedWalletAddress(null)
+            );
+        }
+    }
+}

Assets/SequenceSDK/WaaS/Tests/SequenceLoginTests.cs

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.44657815, g: 0.49641192, b: 0.57481617, a: 1}
+  m_IndirectSpecularColor: {r: 0.44657844, g: 0.49641258, b: 0.57481694, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
@@ -252,7 +252,7 @@ MonoBehaviour:
       saleAddress: 0x476f14887372e21fea64baba11c849b518a2e928
       itemsForSale: 010000000200000003000000
     secondarySale:
-      collectionAddress: 0x079294e6ffec16234578c672fa3fbfd4b6c48640
+      collectionAddress: 0x0ee3af1874789245467e7482f042ced9c5171073
       chain: 137
     checkout: 1
   _featureSelection: {fileID: 1094787527}

Assets/SequenceSDK/WaaS/Tests/SequenceLoginTests.cs.meta

@@ -115,7 +115,7 @@ public static SequenceInGameShop OpenSequenceInGameShop(Transform parent, IWalle
         public static ViewMarketplaceListingsPanel OpenViewMarketplaceListingsPanel(Transform parent, IWallet wallet, Chain chain, Address marketplaceCollectionAddress, Action onClose = null)
         {
             return GetOrSpawnBoilerplate<ViewMarketplaceListingsPanel>("Marketplace/ViewMarketplaceListingsPanel", parent, 
-                b => b.Open(wallet, chain, onClose));
+                b => b.Open(wallet, chain, marketplaceCollectionAddress, onClose));
         }
 
         /// <summary>

Packages/Sequence-Unity/Sequence/Samples~/DemoScene/Demo.unity

@@ -72,8 +72,19 @@ public static SequenceLogin GetInstanceToFederateAuth(Address connectedWalletAdd
 
         public void SetConnectedWalletAddress(Address connectedWalletAddress)
         {
+            if (connectedWalletAddress == null)
+            {
+                Debug.LogError($"The connected wallet address cannot be null or empty.");
+                throw new ArgumentNullException(nameof(connectedWalletAddress));
+            }
+            
             _connectedWalletAddress = connectedWalletAddress;
         }
+        
+        public void RemoveConnectedWalletAddress()
+        {
+            _connectedWalletAddress = null;
+        }
 
         [Obsolete("Use GetInstance() instead.")]
         public SequenceLogin(IValidator validator = null, IAuthenticator authenticator = null, IWaaSConnector connector = null, bool automaticallyFederateAccountsWhenPossible = true, Address connectedWalletAddress = null)
@@ -123,7 +134,7 @@ public void ResetSessionId()
         public void ResetLoginAfterTest()
         {
             _connector = this;
-            SetConnectedWalletAddress(null);
+            RemoveConnectedWalletAddress();
             SetupAuthenticator();
         }
 

Packages/Sequence-Unity/Sequence/SequenceFrontend/Scripts/UI/Boilerplates/BoilerplateFactory.cs

@@ -31,6 +31,7 @@ public enum Chain
         Telos = 40,
         Moonbeam = 1284,
         Etherlink = 42793,
+        [Obsolete("Chain is not currently supported")]
         XR1 = 273,
 
         // Testnets
@@ -44,6 +45,7 @@ public enum Chain
         TestnetOptimisticSepolia = 11155420,
         [Obsolete("Chain is no longer active; use TestnetSoneiumMinato instead")]
         TestnetAstarZKyoto = 6038361,
+        [Obsolete("Chain is not currently supported")]
         TestnetXrSepolia = 2730,
         TestnetB3Sepolia = 1993,
         TestnetAPEChain = 33111,

Packages/Sequence-Unity/Sequence/SequenceSDK/EmbeddedWallet/SequenceLogin.cs

@@ -26,7 +26,8 @@ public static string GetChainId(this Chain chain)
 
         public static bool IsActive(this Chain chain)
         {
-            return !(chain == Chain.None || chain == Chain.AstarZKEvm || chain == Chain.TestnetAstarZKyoto || chain == Chain.TestnetBorne);
+            return !(chain == Chain.None || chain == Chain.AstarZKEvm || chain == Chain.TestnetAstarZKyoto ||
+                     chain == Chain.TestnetBorne || chain == Chain.XR1 || chain == Chain.TestnetXrSepolia);
         }
     }