[Mainnet] Hashbattle Gaming Contract

Mainnet/HashBattle/HashBattle.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31624.102
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HashBattle", "HashBattle\HashBattle.csproj", "{D711FA52-750E-481B-9BC5-2E07EBF58240}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HashBattleTest", "HashBattleTest\HashBattleTest.csproj", "{2A7F2670-A17F-46E6-BF35-A2C55BC7DCB1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{D711FA52-750E-481B-9BC5-2E07EBF58240}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D711FA52-750E-481B-9BC5-2E07EBF58240}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D711FA52-750E-481B-9BC5-2E07EBF58240}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D711FA52-750E-481B-9BC5-2E07EBF58240}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2A7F2670-A17F-46E6-BF35-A2C55BC7DCB1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2A7F2670-A17F-46E6-BF35-A2C55BC7DCB1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2A7F2670-A17F-46E6-BF35-A2C55BC7DCB1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2A7F2670-A17F-46E6-BF35-A2C55BC7DCB1}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {88A96B52-6F00-40C9-AA28-C3D79E3BC0DF}
+	EndGlobalSection
+EndGlobal

Mainnet/HashBattle/HashBattle/Arena.cs

@@ -0,0 +1,194 @@
+using Stratis.SmartContracts;
+using System;
+using System.Text;
+
+/// <summary>
+/// A Stratis smart contract for running a game battle where owner will start the battle and maximum 4 users can enter a battle
+/// </summary>
+public class Arena : SmartContract
+{
+    public Arena(ISmartContractState smartContractState)
+    : base(smartContractState)
+    {
+        BattleOwner = Message.Sender;
+    }
+
+    /// <summary>
+    /// Set the address deploying the contract as battle owner
+    /// </summary>
+    private Address BattleOwner
+    {
+        get => PersistentState.GetAddress(nameof(BattleOwner));
+        set => PersistentState.SetAddress(nameof(BattleOwner), value);
+    }
+
+    /// <summary>
+    /// Battle owner will start the battle
+    /// </summary>
+    public bool StartBattle(ulong battleId, ulong fee)
+    {
+        Assert(Message.Sender == BattleOwner, "Only battle owner can start game.");
+
+        var battle = new BattleMain();
+        battle.BattleId = battleId;
+        battle.MaxUsers = 4;
+        battle.Fee = fee;
+        battle.Users = new Address[battle.MaxUsers];
+        SetBattle(battleId, battle);
+
+        Log(battle);
+        return true;
+    }
+
+    /// <summary>
+    /// 4 different user will enter the battle
+    /// </summary>
+    public bool EnterBattle(ulong battleId, uint userindex)
+    {
+        var battle = GetBattle(battleId);
+
+        Assert(battle.Winner == Address.Zero, "Battle ended.");
+
+        Assert(battle.Fee == Message.Value, "Battle amount is not matching.");
+
+        var user = GetUser(battleId, Message.Sender);
+
+        Assert(!user.ScoreSubmitted, "The user already submitted score.");
+
+        user.Address = Message.Sender;
+
+        SetUser(battleId, Message.Sender, user);
+
+        battle.Users.SetValue(user.Address, userindex);
+        SetBattle(battleId, battle);
+
+        Log(battle);
+        return true;
+    }
+
+    /// <summary>
+    /// 4 different user will end the battle and submit the score
+    /// </summary>
+    public bool EndBattle(Address userAddress, ulong battleId, uint score, bool IsBattleOver)
+    {
+        Assert(Message.Sender == BattleOwner, "Only battle owner can end game.");
+
+        var battle = GetBattle(battleId);
+
+        Assert(battle.Winner == Address.Zero, "Battle ended.");
+
+        var user = GetUser(battleId, userAddress);
+
+        Assert(!user.ScoreSubmitted, "The user already submitted score.");
+
+        user.Score = score;
+        user.ScoreSubmitted = true;
+
+        SetUser(battleId, userAddress, user);
+
+        if (IsBattleOver)
+            ProcessWinner(battle);
+
+        Log(user);
+        return true;
+    }
+
+    /// <summary>
+    /// Get winner address
+    /// </summary>
+    public Address GetWinner(ulong battleId)
+    {
+        var battle = GetBattle(battleId);
+        Log(battle);
+        return battle.Winner;
+    }
+
+    /// <summary>
+    /// Process winner when all user scores are submitted
+    /// </summary>
+    private void ProcessWinner(BattleMain battle)
+    {
+        if (battle.Users.Length <= 4)
+        {
+            foreach (Address userAddress in battle.Users)
+            {
+                var user = GetUser(battle.BattleId, userAddress);
+                if (!user.ScoreSubmitted)
+                    return;
+            }
+        }
+        uint winnerIndex = GetWinnerIndex(battle.BattleId, battle.Users);
+        if (battle.Winner == Address.Zero)
+        {
+            battle.Winner = battle.Users[winnerIndex];
+            SetBattle(battle.BattleId, battle);
+            ProcessPrize(battle.BattleId);
+        }
+    }
+
+    /// <summary>
+    /// Get winner user index from battle users
+    /// </summary>
+    private uint GetWinnerIndex(ulong battleid, Address[] users)
+    {
+        uint winningScore = 0;
+        uint winningScoreIndex = 0;
+        for (uint i = 0; i < users.Length; i++)
+        {
+            var user = GetUser(battleid, users[i]);
+            if (user.Score > winningScore)
+            {
+                winningScore = user.Score;
+                winningScoreIndex = i;
+            }
+        }
+        return winningScoreIndex;
+    }
+
+    /// <summary>
+    /// Send 3/4 amount to winner and 1/4 amount to battle owner
+    /// </summary>
+    private void ProcessPrize(ulong battleid)
+    {
+        var battle = GetBattle(battleid);
+        ulong prize = battle.Fee * (battle.MaxUsers - 1);
+        Transfer(battle.Winner, prize);
+        Transfer(BattleOwner, battle.Fee);
+    }
+
+    private void SetUser(ulong battleid, Address address, BattleUser user)
+    {
+        PersistentState.SetStruct($"user:{battleid}:{address}", user);
+    }
+
+    private BattleUser GetUser(ulong battleid, Address address)
+    {
+        return PersistentState.GetStruct<BattleUser>($"user:{battleid}:{address}");
+    }
+
+    private void SetBattle(ulong battleid, BattleMain battle)
+    {
+        PersistentState.SetStruct($"battle:{battleid}", battle);
+    }
+
+    private BattleMain GetBattle(ulong battleid)
+    {
+        return PersistentState.GetStruct<BattleMain>($"battle:{battleid}");
+    }
+
+    public struct BattleMain
+    {
+        public ulong BattleId;
+        public Address Winner;
+        public Address[] Users;
+        public uint MaxUsers;
+        public ulong Fee;
+    }
+
+    public struct BattleUser
+    {
+        public Address Address;
+        public uint Score;
+        public bool ScoreSubmitted;
+    }
+}

Mainnet/HashBattle/HashBattle/HashBattle.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+
+	<LangVersion>8.0</LangVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Stratis.SmartContracts" Version="1.2.1" />
+  </ItemGroup>
+</Project>

Mainnet/HashBattle/HashBattleTest/ArenaTest.cs

@@ -0,0 +1,145 @@
+using System;
+using Moq;
+using Stratis.SmartContracts;
+using Stratis.SmartContracts.CLR;
+using Xunit;
+using static Arena;
+
+namespace HashBattleTest
+{
+    public class ArenaTest
+    {
+        private readonly IPersistentState state;
+        private readonly Mock<ISmartContractState> mockContractState;
+        private readonly Mock<IPersistentState> mockPersistentState;
+        private readonly Mock<IContractLogger> mockContractLogger;
+        private readonly Mock<IInternalTransactionExecutor> mTransactionExecutor;
+        private Address contract;
+        private Address ownerAddress;
+        private Address playerAddress1;
+        private Address playerAddress2;
+        private Address playerAddress3;
+        private Address playerAddress4;
+
+        public ArenaTest()
+        {
+            this.state = new InMemoryState();
+            this.mockPersistentState = new Mock<IPersistentState>();
+            this.mockContractState = new Mock<ISmartContractState>();
+            this.mockContractLogger = new Mock<IContractLogger>();
+            this.mTransactionExecutor = new Mock<IInternalTransactionExecutor>();
+            this.mockContractState.Setup(s => s.PersistentState).Returns(this.state);
+            this.mockContractState.Setup(s => s.ContractLogger).Returns(this.mockContractLogger.Object);
+            this.mockContractState.Setup(s => s.InternalTransactionExecutor).Returns(this.mTransactionExecutor.Object);
+            this.contract = "0x0000000000000000000000000000000000000001".HexToAddress();
+            this.ownerAddress = "0x0000000000000000000000000000000000000002".HexToAddress();
+            this.playerAddress1 = "0x0000000000000000000000000000000000000003".HexToAddress();
+            this.playerAddress2 = "0x0000000000000000000000000000000000000004".HexToAddress();
+            this.playerAddress3 = "0x0000000000000000000000000000000000000005".HexToAddress();
+            this.playerAddress4 = "0x0000000000000000000000000000000000000006".HexToAddress();
+        }
+
+
+        [Fact]
+        public void TestBattle()
+        {
+            Arena arena = StartBattleTest();
+            Player1EnterGameTest(arena);
+            Player2EnterGameTest(arena);
+            Player3EnterGameTest(arena);
+            Player4EnterGameTest(arena);
+            Player1EndGameTest(arena);
+            Player2EndGameTest(arena);
+            Player3EndGameTest(arena);
+            Player4EndGameTest(arena);
+            GetGameWinnerTest(arena);
+        }
+
+        private Arena StartBattleTest()
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            Arena arena = new Arena(this.mockContractState.Object);
+            arena.StartBattle(1, 1);
+
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+            return arena;
+        }
+
+        private void Player1EnterGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.playerAddress1, 1));
+            arena.EnterBattle(1, 0);
+
+            Assert.Equal(this.playerAddress1, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress1}").Address);
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+        }
+
+        private void Player2EnterGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.playerAddress2, 1));
+            arena.EnterBattle(1, 1);
+
+            Assert.Equal(this.playerAddress2, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress2}").Address);
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+        }
+
+        private void Player3EnterGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.playerAddress3, 1));
+            arena.EnterBattle(1, 2);
+
+            Assert.Equal(this.playerAddress3, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress3}").Address);
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+        }
+
+        private void Player4EnterGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.playerAddress4, 1));
+            arena.EnterBattle(1, 3);
+
+            Assert.Equal(this.playerAddress4, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress4}").Address);
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+        }
+
+        private void Player1EndGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            arena.EndBattle(this.playerAddress1, 1, 10, false);
+
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress1}")));
+        }
+
+        private void Player2EndGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            arena.EndBattle(this.playerAddress2, 1, 20, false);
+
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress2}")));
+        }
+
+        private void Player3EndGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            arena.EndBattle(this.playerAddress3, 1, 30, false);
+
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress3}")));
+        }
+
+        private void Player4EndGameTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            arena.EndBattle(this.playerAddress4, 1, 40, true);
+
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleUser>($"user:{1}:{this.playerAddress4}")));
+        }
+
+        private void GetGameWinnerTest(Arena arena)
+        {
+            this.mockContractState.Setup(m => m.Message).Returns(new Message(this.contract, this.ownerAddress, 0));
+            Address winner = arena.GetWinner(1);
+
+            Assert.Equal(this.playerAddress4, winner);
+            this.mockContractLogger.Verify(m => m.Log(this.mockContractState.Object, state.GetStruct<BattleMain>($"battle:{1}")));
+        }
+    }
+}