private void ExecuteCycle(int n, int f)
        {
            var stateManager       = _container?.Resolve <IStateManager>();
            var contractRegisterer = _container?.Resolve <IContractRegisterer>();
            var tx        = new TransactionReceipt();
            var sender    = new BigInteger(0).ToUInt160();
            var context   = new InvocationContext(sender, stateManager !.LastApprovedSnapshot, tx);
            var contract  = new GovernanceContract(context);
            var ecdsaKeys = Enumerable.Range(0, n)
                            .Select(_ => Crypto.GeneratePrivateKey())
                            .Select(x => x.ToPrivateKey())
                            .Select(x => new EcdsaKeyPair(x))
                            .ToArray();
            var pubKeys = ecdsaKeys.Select(x => CryptoUtils.EncodeCompressed(x.PublicKey)).ToArray();
            var keyGens = Enumerable.Range(0, n)
                          .Select(i => new TrustlessKeygen(ecdsaKeys[i], ecdsaKeys.Select(x => x.PublicKey), f, 0))
                          .ToArray();
            var cycle = 0.ToUInt256();

            var messageLedger = new RandomSamplingQueue <QueueItem>();

            messageLedger.Enqueue(new QueueItem(-1, null));

            // call ChangeValidators method
            {
                byte[][] validators = pubKeys;
                var      input      = ContractEncoder.Encode(GovernanceInterface.MethodChangeValidators, cycle, validators);
                var      call       = contractRegisterer !.DecodeContract(context, ContractRegisterer.GovernanceContract, input);
                Assert.IsNotNull(call);
                var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                Assert.AreEqual(ExecutionStatus.Ok, contract.ChangeValidators(cycle, validators, frame));
            }
            // check correct validator
            {
                for (var i = 0; i < n; i++)
                {
                    var input = ContractEncoder.Encode(GovernanceInterface.MethodIsNextValidator, pubKeys[i]);
                    var call  = contractRegisterer.DecodeContract(context, ContractRegisterer.GovernanceContract, input);
                    Assert.IsNotNull(call);
                    var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                    Assert.AreEqual(ExecutionStatus.Ok, contract.IsNextValidator(pubKeys[i], frame));
                    Assert.AreEqual(frame.ReturnValue, 1.ToUInt256().ToBytes());
                }
            }
            // check incorrect validator
            {
                byte[] incorrectPubKey = pubKeys[0].Reverse().ToArray();
                var    input           = ContractEncoder.Encode(GovernanceInterface.MethodIsNextValidator, incorrectPubKey);
                var    call            = contractRegisterer.DecodeContract(context, ContractRegisterer.GovernanceContract, input);
                Assert.IsNotNull(call);
                var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                Assert.AreEqual(ExecutionStatus.Ok, contract.IsNextValidator(incorrectPubKey, frame));
                Assert.AreEqual(frame.ReturnValue, 0.ToUInt256().ToBytes());
            }

            while (messageLedger.Count > 0)
            {
                QueueItem?msg;
                var       success = messageLedger.TryDequeue(out msg);
                Assert.IsTrue(success);
                switch (msg.payload)
                {
                case null:
                    for (var i = 0; i < n; ++i)
                    {
                        messageLedger.Enqueue(new QueueItem(i, keyGens[i].StartKeygen()));
                    }
                    break;

                case CommitMessage commitMessage:
                    for (var i = 0; i < n; ++i)
                    {
                        if (i == 0)
                        {
                            byte[]   commitment    = commitMessage.Commitment.ToBytes();
                            byte[][] encryptedRows = commitMessage.EncryptedRows;
                            var      input         = ContractEncoder.Encode(GovernanceInterface.MethodKeygenCommit, cycle, commitment,
                                                                            encryptedRows);
                            var call = contractRegisterer.DecodeContract(context, ContractRegisterer.GovernanceContract, input);
                            Assert.IsNotNull(call);
                            var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                            Assert.AreEqual(ExecutionStatus.Ok, contract.KeyGenCommit(cycle, commitment, encryptedRows, frame));
                            // several calls is ok
                            Assert.AreEqual(ExecutionStatus.Ok, contract.KeyGenCommit(cycle, commitment, encryptedRows, frame));
                        }
                        messageLedger.Enqueue(new QueueItem(i, keyGens[i].HandleCommit(msg.sender, commitMessage)));
                    }
                    break;

                case ValueMessage valueMessage:
                    for (var i = 0; i < n; ++i)
                    {
                        if (i == 0)
                        {
                            var proposer = new BigInteger(msg.sender).ToUInt256();
                            var input    = ContractEncoder.Encode(GovernanceInterface.MethodKeygenSendValue,
                                                                  cycle, proposer, valueMessage.EncryptedValues);
                            var call = contractRegisterer.DecodeContract(context, ContractRegisterer.GovernanceContract,
                                                                         input);
                            Assert.IsNotNull(call);
                            var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                            Assert.AreEqual(ExecutionStatus.Ok,
                                            contract.KeyGenSendValue(cycle, proposer, valueMessage.EncryptedValues,
                                                                     frame));
                        }
                        keyGens[i].HandleSendValue(msg.sender, valueMessage);
                    }
                    break;

                default:
                    Assert.Fail($"Message of type {msg.GetType()} occurred");
                    break;
                }
            }
            Assert.IsTrue(keyGens.All((x) => x.Finished()));

            // finish cycle
            {
                var input = ContractEncoder.Encode(GovernanceInterface.MethodFinishCycle, cycle);
                var call  = contractRegisterer.DecodeContract(context, ContractRegisterer.GovernanceContract, input);
                Assert.IsNotNull(call);
                var frame = new SystemContractExecutionFrame(call !, context, input, 100_000_000);
                // set next cycle block number in frame:
                frame.InvocationContext.Receipt.Block = StakingContract.CycleDuration;
                Assert.AreEqual(ExecutionStatus.Ok, contract.FinishCycle(cycle, frame));
            }
        }
Exemple #2
0
        private static ThresholdKeyring[] SimulateKeygen(int n, int f, DeliveryServiceMode mode)
        {
            var ecdsaKeys = Enumerable.Range(0, n)
                            .Select(_ => Crypto.GeneratePrivateKey())
                            .Select(x => x.ToPrivateKey())
                            .Select(x => new EcdsaKeyPair(x))
                            .ToArray();

            var keyGens = Enumerable.Range(0, n)
                          .Select(i => new TrustlessKeygen(ecdsaKeys[i], ecdsaKeys.Select(x => x.PublicKey), f, 0))
                          .ToArray();


            var messageLedger = new RandomSamplingQueue <QueueItem>();

            messageLedger.Enqueue(new QueueItem(-1, null));

            var curKeys = keyGens.Select(_ => (ThresholdKeyring?)null).ToArray();

            while (messageLedger.Count > 0)
            {
                QueueItem?msg;
                var       success = mode switch
                {
                    DeliveryServiceMode.TAKE_FIRST => messageLedger.TryDequeue(out msg),
                    DeliveryServiceMode.TAKE_LAST => messageLedger.TryTakeLast(out msg),
                    DeliveryServiceMode.TAKE_RANDOM => messageLedger.TrySample(out msg),
                    _ => throw new NotImplementedException($"Unknown mode {mode}")
                };
                Assert.IsTrue(success);
                switch (msg?.payload)
                {
                case null:
                    for (var i = 0; i < n; ++i)
                    {
                        messageLedger.Enqueue(new QueueItem(i, keyGens[i].StartKeygen()));
                    }
                    break;

                case CommitMessage commitMessage:
                    for (var i = 0; i < n; ++i)
                    {
                        messageLedger.Enqueue(new QueueItem(i, keyGens[i].HandleCommit(msg.sender, commitMessage)));
                    }
                    break;

                case ValueMessage valueMessage:
                    for (var i = 0; i < n; ++i)
                    {
                        keyGens[i].HandleSendValue(msg.sender, valueMessage);
                    }
                    break;

                default:
                    Assert.Fail($"Message of type {msg.GetType()} occurred");
                    break;
                }

                for (var i = 0; i < n; ++i)
                {
                    var curKey = keyGens[i].TryGetKeys();
                    if (curKey is null)
                    {
                        Assert.AreEqual(null, curKeys[i]);
                        continue;
                    }

                    if (!curKeys[i].HasValue)
                    {
                        curKeys[i] = curKey;
                        continue;
                    }

                    Assert.IsTrue(curKey.Value.TpkePrivateKey.ToBytes()
                                  .SequenceEqual(curKeys[i] !.Value.TpkePrivateKey.ToBytes()));
                    Assert.AreEqual(curKey.Value.PublicPartHash(), curKeys[i] !.Value.PublicPartHash());
                }

                for (var i = 0; i < n; ++i)
                {
                    keyGens[i] = TestSerializationRoundTrip(keyGens[i], ecdsaKeys[i]);
                }
            }

            for (var i = 0; i < n; ++i)
            {
                Assert.IsTrue(keyGens[i].Finished());
                Assert.AreNotEqual(curKeys[i], null);
            }

            var keys = keyGens
                       .Select(x => x.TryGetKeys() ?? throw new Exception())
                       .ToArray();

            for (var i = 0; i < n; ++i)
            {
                Assert.AreEqual(keys[0].TpkePublicKey, keys[i].TpkePublicKey);
                Assert.AreEqual(keys[0].ThresholdSignaturePublicKeySet, keys[i].ThresholdSignaturePublicKeySet);
            }

            return(keys);
        }