[SC] Embedded Smart Contracts

src/NBitcoin/Network.cs

@@ -211,7 +211,7 @@ public interface IEmbeddedContractContainer
         /// Returns the identifiers of all defined contracts, whether active or inactive.
         /// </summary>
         /// <returns></returns>
-        IEnumerable<uint160> GetContractIdentifiers();
+        IEnumerable<uint160> GetEmbeddedContractAddresses();
 
         /// <summary>
         /// Extracts the contract type and version from a contract hash.
@@ -241,6 +241,8 @@ public interface IFederations
         IFederation GetFederationAtHeight(byte[] federationId, ulong blockHeight, uint256 blockHash);
 
         IFederation GetOnlyFederation();
+
+        IEnumerable<IFederation> GetFederations();
     }
 
     public class Federations : IFederations
@@ -252,6 +254,11 @@ public Federations()
             this.federations = new Dictionary<FederationId, IFederation>();
         }
 
+        public IEnumerable<IFederation> GetFederations()
+        {
+            return this.federations.Values.AsEnumerable();
+        }
+
         public IFederation GetFederation(FederationId federationId)
         {
             return this.federations.TryGetValue(federationId, out IFederation federation) ? federation : null;

src/Stratis.Bitcoin.Features.SmartContracts.Tests/PoS/EmbeddedContractContainerTests.cs

@@ -11,32 +11,27 @@
 
 namespace Stratis.Bitcoin.Features.SmartContracts.Tests.PoS
 {
-    public class TestEmbeddedContract
-    {
-
-    }
-
     public class EmbeddedContractContainerTests
     {
         [Fact]
         public void CanUseEmbeddedContractContainer()
         {
             var network = new StraxMain();
-            EmbeddedContractIdentifier contractId = new EmbeddedContractIdentifier(1, 1);
+            uint160 embeddedContractAddress = EmbeddedContractAddress.Create(typeof(Authentication), 1);
             var container = new EmbeddedContractContainer(
                 network,
-                new Dictionary<uint160, EmbeddedContractDescriptor> {
-                    { contractId, new EmbeddedContractDescriptor(typeof(TestEmbeddedContract).AssemblyQualifiedName,new[] { (1, (int?)10) }, "SystemContracts", true) } },
+                new List<EmbeddedContractVersion> {
+                    { new EmbeddedContractVersion(typeof(Authentication), 1, new[] { (1, (int?)10) }, "SystemContracts", true) } },
                 null);
 
-            uint160 id = container.GetContractIdentifiers().First();
+            uint160 address = container.GetEmbeddedContractAddresses().First();
 
-            Assert.True(EmbeddedContractIdentifier.IsEmbedded(contractId));
+            Assert.True(EmbeddedContractAddress.IsEmbedded(embeddedContractAddress));
 
-            Assert.True(container.TryGetContractTypeAndVersion(id, out string contractType, out uint version));
+            Assert.True(container.TryGetContractTypeAndVersion(address, out string contractType, out uint version));
 
-            Assert.Equal(typeof(TestEmbeddedContract).AssemblyQualifiedName, contractType);
-            Assert.Equal(contractId.Version, version);
+            Assert.Equal(typeof(Authentication).AssemblyQualifiedName, contractType);
+            Assert.Equal(embeddedContractAddress.GetEmbeddedVersion(), version);
 
             ChainedHeader chainedHeader = new ChainedHeader(0, null, null) { };
             var mockChainStore = new Mock<IChainStore>();
@@ -46,25 +41,25 @@ public void CanUseEmbeddedContractContainer()
 
             // Active if previous header is at height 9.
             chainedHeader.SetPrivatePropertyValue("Height", 9);
-            Assert.True(container.IsActive(id, chainedHeader, (h, d) => false));
+            Assert.True(container.IsActive(address, chainedHeader, (h, d) => false));
 
             // Inactive if previous header is at height 10.
             chainedHeader.SetPrivatePropertyValue("Height", 10);
-            Assert.False(container.IsActive(id, chainedHeader, (h, d) => false));
+            Assert.False(container.IsActive(address, chainedHeader, (h, d) => false));
 
             // Inactive if previous header is at height 10 unless activated by BIP 9.
             chainedHeader.SetPrivatePropertyValue("Height", 10);
-            Assert.True(container.IsActive(id, chainedHeader, (h, d) => true));
+            Assert.True(container.IsActive(address, chainedHeader, (h, d) => true));
         }
 
         [Fact]
         public void CanDereferenceContractTypes()
         {
             foreach (Network network in new Network[] { new StraxMain(), new StraxTest(), new StraxRegTest() })
             {
-                foreach (uint160 id in network.EmbeddedContractContainer.GetContractIdentifiers())
+                foreach (uint160 address in network.EmbeddedContractContainer.GetEmbeddedContractAddresses())
                 {
-                    Assert.True(network.EmbeddedContractContainer.TryGetContractTypeAndVersion(id, out string typeName, out uint version));
+                    Assert.True(network.EmbeddedContractContainer.TryGetContractTypeAndVersion(address, out string typeName, out uint version));
 
                     Assert.NotNull(Type.GetType(typeName));
                 }

src/Stratis.SmartContracts.CLR.Tests/SmartContracts/Authentication.cs → src/Stratis.Bitcoin.Features.SmartContracts/Embedded/Authentication.cs

@@ -4,14 +4,15 @@
 using Stratis.SmartContracts.CLR;
 using ECRecover = Stratis.SCL.Crypto.ECRecover;
 
+[EmbeddedContract(EmbeddedContractType.Authentication)]
 public class Authentication : SmartContract
 {
     const string primaryGroup = "main";
     private readonly uint version;
 
     public Authentication(ISmartContractState state, Network network) : base(state)
     {
-        uint version = new EmbeddedContractIdentifier(state.Message.ContractAddress.ToUint160()).Version;
+        uint version = state.Message.ContractAddress.ToUint160().GetEmbeddedVersion();
 
         Assert(version == 1, "Only a version of 1 is supported.");
 

src/Stratis.Bitcoin.Features.SmartContracts/Embedded/Multisig.cs

@@ -0,0 +1,152 @@
+using System.Linq;
+using NBitcoin;
+using Stratis.SmartContracts;
+using Stratis.SmartContracts.CLR;
+
+[EmbeddedContract(EmbeddedContractType.Multisig)]
+public class MultiSig : SmartContract
+{
+    const string primaryGroup = "main";
+    private readonly uint version;
+    private readonly Authentication authentication;
+
+    public MultiSig(ISmartContractState state, IPersistenceStrategy persistenceStrategy, Network network) : base(state)
+    {
+        uint version = state.Message.ContractAddress.ToUint160().GetEmbeddedVersion();
+
+        Assert(version == 1, "Only a version of 1 is supported.");
+
+        this.version = version;
+        this.authentication = new Authentication(GetState(state, persistenceStrategy, EmbeddedContractAddress.Create(typeof(Authentication), 1)), network);
+
+        // Exit if already initialized.
+        if (this.Initialized)
+            return;
+
+        foreach (IFederation federation in network.Federations.GetFederations())
+        {
+            (PubKey[] pubKeys, int signaturesRequired) = federation.GetFederationDetails();
+            AddFederation(federation.Id.ToHex(network), (uint)signaturesRequired, pubKeys.Select(pk => pk.ToHex()).ToArray());
+        }
+
+        this.Initialized = true;
+    }
+
+    private ISmartContractState GetState(ISmartContractState state, IPersistenceStrategy persistenceStrategy, uint160 address)
+    {
+        return new SmartContractState(state.Block, state.Message, new PersistentState(persistenceStrategy, state.Serializer, address),
+            state.Serializer, state.ContractLogger, state.InternalTransactionExecutor, state.InternalHashHelper, state.GetBalance);
+    }
+
+    public bool Initialized
+    {
+        get => this.State.GetBool("Initialized");
+        set => this.State.SetBool("Initialized", value);
+    }
+
+    private void VerifySignatures(string group, byte[] signatures, string authorizationChallenge)
+    {
+        this.authentication.VerifySignatures(group, signatures, authorizationChallenge);
+    }
+
+    private void AddFederation(string federationId, uint quorum, string[] pubKeys)
+    {
+        SetFederationMembers(federationId, pubKeys);
+        SetFederationQuorum(federationId, quorum);
+    }
+
+    public string[] GetFederationMembers(string federationId)
+    {
+        Assert(!string.IsNullOrEmpty(federationId));
+        return this.State.GetArray<string>($"Members:{federationId}");
+    }
+
+    private void SetFederationMembers(string federationId, string[] values)
+    {
+        this.State.SetArray($"Members:{federationId}", values);
+    }
+
+    public uint GetFederationQuorum(string federationId)
+    {
+        Assert(!string.IsNullOrEmpty(federationId));
+        return this.State.GetUInt32($"Quorum:{federationId}");
+    }
+
+    private void SetFederationQuorum(string federationId, uint quorum)
+    {
+        this.State.SetUInt32($"Quorum:{federationId}", quorum);
+    }
+
+    private uint GetFederationNonce(string federationId)
+    {
+        return this.State.GetUInt32($"Nonce:{federationId}");
+    }
+
+    private void SetFederationNonce(string federationId, uint value)
+    {
+        this.State.SetUInt32($"Nonce:{federationId}", value);
+    }
+
+    public void AddMember(byte[] signatures, string federationId, string pubKey, uint newSize, uint newQuorum)
+    {
+        Assert(!string.IsNullOrEmpty(federationId));
+        Assert(newSize >= newQuorum, "The number of signatories can't be less than the quorum.");
+        Assert(new PubKey(pubKey).ToHex().ToUpper() == pubKey.ToUpper());
+
+        string[] signatories = this.GetFederationMembers(federationId);
+        foreach (string signatory in signatories)
+            Assert(signatory != pubKey, "The signatory already exists.");
+
+        Assert((signatories.Length + 1) == newSize, "The expected size is incorrect.");
+
+        // The nonce is used to prevent replay attacks.
+        uint nonce = this.GetFederationNonce(federationId);
+
+        // Validate or provide a unique challenge to the signatories that depends on the exact action being performed.
+        // If the signatures are missing or fail validation contract execution will stop here.
+        this.VerifySignatures(primaryGroup, signatures, $"{nameof(AddMember)}(Nonce:{nonce},FederationId:{federationId},PubKey:{pubKey},NewSize:{newSize},NewQuorum:{newQuorum})");
+
+        System.Array.Resize(ref signatories, signatories.Length + 1);
+        signatories[signatories.Length - 1] = pubKey;
+
+        this.SetFederationMembers(federationId, signatories);
+        this.SetFederationQuorum(federationId, newQuorum);
+        this.SetFederationNonce(federationId, nonce + 1);
+    }
+
+    public void RemoveMember(byte[] signatures, string federationId, string pubKey, uint newSize, uint newQuorum)
+    {
+        Assert(!string.IsNullOrEmpty(federationId));
+        Assert(newSize >= newQuorum, "The number of signatories can't be less than the quorum.");
+        Assert(new PubKey(pubKey).ToHex().ToUpper() == pubKey.ToUpper());
+
+        string[] prevSignatories = this.GetFederationMembers(federationId);
+        string[] signatories = new string[prevSignatories.Length - 1];
+
+        int i = 0;
+        foreach (string item in prevSignatories)
+        {
+            if (item == pubKey)
+            {
+                continue;
+            }
+
+            Assert(signatories.Length != i, "The signatory does not exist.");
+
+            signatories[i++] = item;
+        }
+
+        Assert(newSize == signatories.Length, "The expected size is incorrect.");
+
+        // The nonce is used to prevent replay attacks.
+        uint nonce = this.GetFederationNonce(federationId);
+
+        // Validate or provide a unique challenge to the signatories that depends on the exact action being performed.
+        // If the signatures are missing or fail validation contract execution will stop here.
+        this.VerifySignatures(primaryGroup, signatures, $"{nameof(RemoveMember)}(Nonce:{nonce},FederationId:{federationId},PubKey:{pubKey},NewSize:{newSize},NewQuorum:{newQuorum})");
+
+        this.SetFederationMembers(federationId, signatories);
+        this.SetFederationQuorum(federationId, newQuorum);
+        this.SetFederationNonce(federationId, nonce + 1);
+    }
+}

src/Stratis.Bitcoin.Features.SmartContracts/PoS/EmbeddedContractContainer.cs

@@ -10,18 +10,25 @@ namespace Stratis.Bitcoin.Features.SmartContracts.PoS
     /// <summary>
     /// Holds the information and logic to determines whether an embedded system contract should be active.
     /// </summary>
-    public class EmbeddedContractDescriptor
+    public class EmbeddedContractVersion
     {
-        public EmbeddedContractDescriptor(string contractType, (int start, int? end)[] activationHistory, string activationName, bool activationState)
+        public EmbeddedContractVersion(Type contractType, uint version, (int start, int? end)[] activationHistory, string activationName, bool activationState)
         {
             this.ContractType = contractType;
+            this.Version = version;
             this.ActivationHistory = activationHistory;
             this.ActivationName = activationName;
             this.ActivationState = activationState;
         }
 
+        /// <summary>The contract version that this information applies to.</summary>
+        public uint Version { get; private set; }
+
         /// <summary>The <see cref="Type.AssemblyQualifiedName"/> of the contract.</summary>
-        public string ContractType { get; private set; }
+        public Type ContractType { get; private set; }
+
+        /// <summary>The address of the contract.</summary>
+        public uint160 Address => EmbeddedContractAddress.Create(this.ContractType, this.Version);
 
         /// <summary>History of block ranges over which contracts were active.
         /// The BIP9 Deployments array is sometimes cleaned up and the information therein has to be transferred here.</summary>
@@ -42,7 +49,7 @@ public class EmbeddedContractContainer : IEmbeddedContractContainer
         private readonly Network network;
 
         /// <summary>The embedded contracts for this network.</summary>
-        private Dictionary<uint160, EmbeddedContractDescriptor> contracts;
+        private Dictionary<uint160, EmbeddedContractVersion> contracts;
 
         /// <summary>
         /// The addresses (defaults) and quorum of the primary authenticators of this network.
@@ -52,36 +59,38 @@ public class EmbeddedContractContainer : IEmbeddedContractContainer
         /// <summary>The class constructor.</summary>
         public EmbeddedContractContainer(
             Network network,
-            Dictionary<uint160, EmbeddedContractDescriptor> contracts,
+            List<EmbeddedContractVersion> contracts,
             PrimaryAuthenticators primaryAuthenticators)
         {
             this.network = network;
-            this.contracts = contracts;
+            this.contracts = new Dictionary<uint160, EmbeddedContractVersion>();
+            foreach (EmbeddedContractVersion contract in contracts)
+                this.contracts.Add(contract.Address, contract);
             this.PrimaryAuthenticators = primaryAuthenticators;
         }
 
         /// <inheritdoc/>
-        public bool TryGetContractTypeAndVersion(uint160 id, out string contractType, out uint version)
+        public bool TryGetContractTypeAndVersion(uint160 address, out string contractType, out uint version)
         {
-            Guard.Assert(EmbeddedContractIdentifier.IsEmbedded(id));
+            Guard.Assert(EmbeddedContractAddress.IsEmbedded(address));
 
-            version = new EmbeddedContractIdentifier(id).Version;
+            version = address.GetEmbeddedVersion();
 
-            if (!this.contracts.TryGetValue(id, out EmbeddedContractDescriptor contract))
+            if (!this.contracts.TryGetValue(address, out EmbeddedContractVersion contract))
             {
                 contractType = null;
                 return false;
             }
 
-            contractType = contract.ContractType;
+            contractType = contract.ContractType.AssemblyQualifiedName;
 
             return true;
         }
 
         /// <inheritdoc/>
-        public bool IsActive(uint160 id, ChainedHeader previousHeader, Func<ChainedHeader, int, bool> deploymentCondition)
+        public bool IsActive(uint160 address, ChainedHeader previousHeader, Func<ChainedHeader, int, bool> deploymentCondition)
         {
-            if (!this.contracts.TryGetValue(id, out EmbeddedContractDescriptor contract))
+            if (!this.contracts.TryGetValue(address, out EmbeddedContractVersion contract))
                 return false;
 
             bool isActive = contract.ActivationHistory.Any(r => (previousHeader.Height + 1) >= r.start && (r.end == null || (previousHeader.Height + 1) <= r.end));
@@ -97,7 +106,7 @@ public bool IsActive(uint160 id, ChainedHeader previousHeader, Func<ChainedHeade
         }
 
         /// <inheritdoc/>
-        public IEnumerable<uint160> GetContractIdentifiers()
+        public IEnumerable<uint160> GetEmbeddedContractAddresses()
         {
             return this.contracts.Select(c => c.Key);
         }