예제 #1
0
        public async Task Pausable_Feature_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var ownerAccount   = new Account(EthNetwork.Instance.PrefundedPrivateKey);
            var holderAccount1 = EthAccountFactory.Create();

            // Create the ERC20 token...
            var contract = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(ownerAccount), EthNetwork.Instance.GasPriceProvider);
            await contract.DeployAsync();

            // Perform a transfer and check the result...
            await contract.TransferAsync(holderAccount1.Address, 2.Algo());

            Assert.Equal(2.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));

            // Pause the contract...
            await contract.PauseAsync();

            // Ensure the contract cannot be used while is in paused state...
            await Assert.ThrowsAsync <TransactionRejectedException>(
                () => contract.TransferAsync(holderAccount1.Address, 2.Algo()));

            // Ensure the balance was not modified...
            Assert.Equal(2.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));

            // Unpause the contract...
            await contract.UnpauseAsync();

            // Try a new transfer and ensure it succeeded...
            await contract.TransferAsync(holderAccount1.Address, 2.Algo());

            Assert.Equal(4.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));
        }
예제 #2
0
        public async Task Stream_Terminate_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount   = EthAccountFactory.Create();
            var streamOwnerAccount  = EthAccountFactory.Create();
            var streamHolderAccount = EthAccountFactory.Create();
            var referralAccount     = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamHolderAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Store the current balance of the token owner...
            var tokenOwnerAccountBalance = await token.BalanceOfAsync(tokenOwnerAccount.Address);

            // Create the stream...
            var stream = new AlgoStream(EthNetwork.Instance.GetWeb3(streamOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await stream.DeployAsync(1, 2, streamHolderAccount.Address, referralAccount.Address, token.ContractAddress);

            // Add the stream as minter...
            await token.AddMinterAsync(stream.ContractAddress);

            // Setup the clock...
            var clock = await Clock.FromAsync(2019, 3, 1, 15, 30, x => stream.SetCurrentDateTimeAsync(x));

            // Activate the stream...
            await stream.ActivateStreamAsync();

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(15);

            await stream.CollectAsync();

            // Transfer some tokens to the stream...
            await token.TransferAsync(stream.ContractAddress, 100.Algo());

            // Ensure the stream got the tokens...
            Assert.Equal(100.Algo(), await token.BalanceOfAsync(stream.ContractAddress));

            // Terminate the stream...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamOwnerAccount));
            await stream.TerminateAsync();

            // Ensure the stream returned all the tokens...
            Assert.Equal(0, await token.BalanceOfAsync(stream.ContractAddress));
            Assert.Equal(tokenOwnerAccountBalance - 100.Algo(), await token.BalanceOfAsync(tokenOwnerAccount.Address));

            // Ensure the stream is not a minter anymore...
            Assert.False(await token.IsMinterAsync(stream.ContractAddress));
        }
예제 #3
0
        public async Task Stream_Ensure_The_Grace_Period_Is_Honored()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount   = EthAccountFactory.Create();
            var streamOwnerAccount  = EthAccountFactory.Create();
            var streamHolderAccount = EthAccountFactory.Create();
            var referralAccount     = EthAccountFactory.Create();

            BigInteger expectedHolderBalance;
            BigInteger expectedReferralBalance;

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamHolderAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create the stream...
            var stream = new AlgoStream(EthNetwork.Instance.GetWeb3(streamOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await stream.DeployAsync(1, 2, streamHolderAccount.Address, referralAccount.Address, token.ContractAddress);

            // Add the stream as minter...
            await token.AddMinterAsync(stream.ContractAddress);

            // Setup the clock...
            var clock = await Clock.FromAsync(2019, 3, 1, 15, 30, x => stream.SetCurrentDateTimeAsync(x));

            // Activate the stream...
            await stream.ActivateStreamAsync();

            // Ensure the grace period is honored...
            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.PauseStreamingAsync());

            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.DisableStreamAsync());

            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.ChangeStreamSizeAsync(2));

            await clock.AddDaysAsync(1);

            // Ensure the grace period is honored...
            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.PauseStreamingAsync());

            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.DisableStreamAsync());

            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.ChangeStreamSizeAsync(2));

            await clock.AddDaysAsync(1);

            // Now it should work...
            await stream.DisableStreamAsync();
        }
예제 #4
0
        public async Task ReferralPoolTransferToMinerTest()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount = EthAccountFactory.Create();
            var coreTeamAccount   = EthAccountFactory.Create();
            var minerAccounts     = new IAccount[6];
            var referralAccounts  = new IAccount[6];

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(coreTeamAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create a pool...
            var pool1 = new AlgoPool(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await pool1.DeployAsync(1, token.ContractAddress);

            // Transfer some tokens to the pool...
            await token.TransferAsync(pool1.ContractAddress, 100.MAlgo());

            // Create miners for each category...
            AlgoMiner[] miners = new AlgoMiner[6];

            for (byte i = 0; i <= 5; i++)
            {
                // Create an account for the miner and the referral...
                minerAccounts[i]    = EthAccountFactory.Create();
                referralAccounts[i] = EthAccountFactory.Create();

                // Create the miner...
                miners[i] = new AlgoMiner(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
                await miners[i].DeployAsync(0, i, minerAccounts[i].Address, referralAccounts[i].Address, token.ContractAddress);
            }

            // Transfer tokens from the pool to the miners...
            for (int i = 0; i <= 5; i++)
            {
                await pool1.TransferToMinerAsync(miners[i].ContractAddress);
            }

            // Ensure each miner received the proper amount of tokens according its category...
            Assert.Equal(100000.Algo() * 10 / 100, await token.BalanceOfAsync(miners[0].ContractAddress));
            Assert.Equal(1.MAlgo() * 10 / 100, await token.BalanceOfAsync(miners[1].ContractAddress));
            Assert.Equal(2.MAlgo() * 10 / 100, await token.BalanceOfAsync(miners[2].ContractAddress));
            Assert.Equal(3.MAlgo() * 10 / 100, await token.BalanceOfAsync(miners[3].ContractAddress));
            Assert.Equal(4.MAlgo() * 10 / 100, await token.BalanceOfAsync(miners[4].ContractAddress));
            Assert.Equal(5.MAlgo() * 10 / 100, await token.BalanceOfAsync(miners[5].ContractAddress));
        }
        private async Task <IAccount> CreateNewAccountAndTransferFromCreatedAccount(IAccount sourceAccount, BigInteger value)
        {
            var web3 = new Web3(sourceAccount, EthTestNet.TESTNET_URL);

            var destinationAccount = EthAccountFactory.Create();

            var recepit = await web3.TransactionManager.TransactionReceiptService.SendRequestAndWaitForReceiptAsync(() =>
                                                                                                                    web3.TransactionManager.SendTransactionAsync(sourceAccount.Address, destinationAccount.Address, new HexBigInteger(value))
                                                                                                                    );

            return(destinationAccount);
        }
예제 #6
0
        public async Task Deploy_Contract_And_Transfer_Tokens_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var ownerAccount   = new Account(EthNetwork.Instance.PrefundedPrivateKey);
            var holderAccount1 = EthAccountFactory.Create();

            // Create the ERC20 token...
            var contract = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(ownerAccount), EthNetwork.Instance.GasPriceProvider);
            await contract.DeployAsync();

            // Ensure that the initial supply is allocated to the owner...
            Assert.Equal(INITIAL_SUPPLY.Algo(), await contract.BalanceOfAsync(ownerAccount.Address));

            // Perform a transfer...
            await contract.TransferAsync(holderAccount1.Address, 2.Algo());

            // Ensure the receiver got the tokens...
            Assert.Equal(2.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));
        }
예제 #7
0
        public async Task TerminateTest()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount = EthAccountFactory.Create();
            var coreTeamAccount   = EthAccountFactory.Create();
            var minerAccount      = EthAccountFactory.Create();
            var referralAccount   = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(coreTeamAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Store the current balance of the token owner...
            var tokenOwnerAccountBalance = await token.BalanceOfAsync(tokenOwnerAccount.Address);

            // Create a miner...
            var miner1 = new AlgoMiner(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await miner1.DeployAsync(0, 2, minerAccount.Address, referralAccount.Address, token.ContractAddress);

            // Transfer some tokens to the miner...
            await token.TransferAsync(miner1.ContractAddress, 100.Algo());

            // Ensure the receiver got the tokens...
            Assert.Equal(100.Algo(), await token.BalanceOfAsync(miner1.ContractAddress));

            // Terminate the contract.
            await miner1.TerminateAsync();

            // Ensure the contract returned all the tokens...
            Assert.Equal(0, await token.BalanceOfAsync(miner1.ContractAddress));
            Assert.Equal(100.Algo(), await token.BalanceOfAsync(coreTeamAccount.Address));
        }
예제 #8
0
        public Task ExecuteAsync(RuntimeContext context)
        {
            string name = string.IsNullOrWhiteSpace(Name) ?
                          string.Format(CultureInfo.InvariantCulture, DEFAULT_NAME_FORMAT, AccountCounter.Next()) : Name;

            if (context.Accounts.ContainsKey(name))
            {
                throw new Exception($"The name '{name}' already exists.");
            }

            var ethAccountDescriptor = new EthAccountDescriptor(name, EthAccountFactory.Create());

            context.Accounts.Add(name, ethAccountDescriptor);
            context.CurrentAccount = ethAccountDescriptor;

            Console.WriteLine("New account created:");
            Console.WriteLine($"- Name: '{name}'.");
            Console.WriteLine($"- Address: '{ethAccountDescriptor.Account.Address}'.");
            Console.WriteLine($"- Private Key: '{ethAccountDescriptor.Account.PrivateKey}'.");

            return(Task.CompletedTask);
        }
예제 #9
0
        public async Task PublishAndInvokeSmartContract()
        {
            var web3 = new Web3(EthTestNet.TESTNET_URL);

            var account = EthAccountFactory.Create();

            await account.RefillAsync(1);

            web3 = new Web3(account, EthTestNet.TESTNET_URL);

            var createContractReceipt = await web3.Eth.DeployContract.SendRequestAndWaitForReceiptAsync(
                Contracts.Instance.CounterABI,
                Contracts.Instance.CounterBIN,
                account.Address,
                new HexBigInteger(900000));

            var contract = web3.Eth.GetContract(
                Contracts.Instance.CounterABI,
                createContractReceipt.ContractAddress);

            var incrementFunction = contract.GetFunction("increment");
            var getCountFunction  = contract.GetFunction("getCount");

            uint counter = 0;

            var incrementReceipt1 = await incrementFunction.SendTransactionAndWaitForReceiptAsync(account.Address, new HexBigInteger(900000), null);

            counter = await getCountFunction.CallAsync <uint>();

            Assert.Equal((uint)1, counter);

            var incrementReceipt2 = await incrementFunction.SendTransactionAndWaitForReceiptAsync(account.Address, new HexBigInteger(900000), null);

            counter = await getCountFunction.CallAsync <uint>();

            Assert.Equal((uint)2, counter);
        }
예제 #10
0
        public async Task Minter_Role_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var ownerAccount     = new Account(EthNetwork.Instance.PrefundedPrivateKey);
            var holderAccount1   = EthAccountFactory.Create();
            var newMinterAccount = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(newMinterAccount);

            // Create the ERC20 token...
            var contract = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(ownerAccount), EthNetwork.Instance.GasPriceProvider);
            await contract.DeployAsync();

            // Check the total supply...
            Assert.Equal(INITIAL_SUPPLY.Algo(), await contract.TotalSupplyAsync());

            // Mint more tokens...
            await contract.MintAsync(holderAccount1.Address, 100.Algo());

            // Check the total supply...
            Assert.Equal((INITIAL_SUPPLY + 100).Algo(), await contract.TotalSupplyAsync());

            // Check balance of the target account...
            Assert.Equal(100.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));

            // Add a new minter...
            await contract.AddMinterAsync(newMinterAccount.Address);

            // Mint more tokens...
            contract = new AlgoTokenV1(contract.ContractAddress, EthNetwork.Instance.GetWeb3(newMinterAccount), EthNetwork.Instance.GasPriceProvider);
            await contract.MintAsync(holderAccount1.Address, 100.Algo());

            // Check balance of the target account...
            Assert.Equal(200.Algo(), await contract.BalanceOfAsync(holderAccount1.Address));
        }
예제 #11
0
        public async Task Stream_Extended_Workflow_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount   = EthAccountFactory.Create();
            var streamOwnerAccount  = EthAccountFactory.Create();
            var streamHolderAccount = EthAccountFactory.Create();
            var referralAccount     = EthAccountFactory.Create();

            BigInteger expectedHolderBalance;
            BigInteger expectedReferralBalance;

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamHolderAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create the stream...
            var stream = new AlgoStream(EthNetwork.Instance.GetWeb3(streamOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await stream.DeployAsync(1, 2, streamHolderAccount.Address, referralAccount.Address, token.ContractAddress);

            // Add the stream as minter...
            await token.AddMinterAsync(stream.ContractAddress);

            // Setup the clock...
            var clock = await Clock.FromAsync(2019, 3, 1, 15, 30, x => stream.SetCurrentDateTimeAsync(x));

            // Activate the stream...
            await stream.ActivateStreamAsync();

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(15);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 15);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(15);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 30);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(100);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 130);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(400);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 530);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount));
            await clock.AddDaysAsync(3170);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 3700);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));
        }
예제 #12
0
        public async Task Stream_Disable_And_Reset_Test()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount    = EthAccountFactory.Create();
            var streamOwnerAccount   = EthAccountFactory.Create();
            var streamHolderAccount1 = EthAccountFactory.Create();
            var referralAccount1     = EthAccountFactory.Create();
            var streamHolderAccount2 = EthAccountFactory.Create();
            var referralAccount2     = EthAccountFactory.Create();

            BigInteger expectedHolderBalance;
            BigInteger expectedReferralBalance;

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamOwnerAccount);

            await EthNetwork.Instance.RefillAsync(streamHolderAccount1);

            await EthNetwork.Instance.RefillAsync(streamHolderAccount2);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create the stream...
            var stream = new AlgoStream(EthNetwork.Instance.GetWeb3(streamOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await stream.DeployAsync(1, 2, streamHolderAccount1.Address, referralAccount1.Address, token.ContractAddress);

            // Add the stream as minter...
            await token.AddMinterAsync(stream.ContractAddress);

            // Setup the clock...
            var clock = await Clock.FromAsync(2019, 3, 1, 15, 30, x => stream.SetCurrentDateTimeAsync(x));

            // Activate the stream...
            await stream.ActivateStreamAsync();

            // Collect the funds...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount1));
            await clock.AddDaysAsync(5);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 5);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount1.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount1.Address));

            // Disable the stream...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamOwnerAccount));
            await stream.DisableStreamAsync();

            // Ensure funds cannot be collected by the holder anymore...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount1));
            await clock.AddDaysAsync(5);

            await Assert.ThrowsAsync <TransactionRejectedException>(() => stream.CollectAsync());

            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount1.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount1.Address));

            // Ensure funds cannot be collected even if the owner request it...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamOwnerAccount));
            await stream.CollectAsync();

            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount1.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount1.Address));

            // Reset the stream...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamOwnerAccount));
            await stream.ResetStreamAsync(streamHolderAccount2.Address, referralAccount2.Address);

            // Activate the stream...
            await stream.ActivateStreamAsync();

            // Collect the funds of the new holder...
            stream.Bind(EthNetwork.Instance.GetWeb3(streamHolderAccount2));
            await clock.AddDaysAsync(3);

            await stream.CollectAsync();

            expectedHolderBalance   = AlgoStreamFeeAlgorithm.CalculateFees(size: 1, days: 3, startDay: 5);
            expectedReferralBalance = expectedHolderBalance * 10 / 100;
            Assert.Equal(expectedHolderBalance, await token.BalanceOfAsync(streamHolderAccount2.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount2.Address));
        }
예제 #13
0
        public async Task MinerRegistrationTest()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount = EthAccountFactory.Create();
            var coreTeamAccount   = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(coreTeamAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create a fees...
            var fees1 = new AlgoFees(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await fees1.DeployAsync(token.ContractAddress);

            // Create some miners...
            var minerAccounts    = new IAccount[3];
            var referralAccounts = new IAccount[3];

            AlgoMiner[] miners = new AlgoMiner[3];

            for (int i = 0; i < 3; i++)
            {
                // Create an account for the miner and the referral...
                minerAccounts[i]    = EthAccountFactory.Create();
                referralAccounts[i] = EthAccountFactory.Create();

                // Create the miner...
                miners[i] = new AlgoMiner(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
                await miners[i].DeployAsync(0, 2, minerAccounts[i].Address, referralAccounts[i].Address, token.ContractAddress);
            }

            // Register a miner...
            await fees1.RegisterMinerAsync(miners[0].ContractAddress);

            Assert.Equal(1, await fees1.GetMinerCountAsync());
            Assert.Equal(miners[0].ContractAddress, await fees1.GetMinerByIndexAsync(0));

            // Remove the only registered miner.
            await fees1.UnregisterMinerAsync(miners[0].ContractAddress);

            Assert.Equal(0, await fees1.GetMinerCountAsync());

            // Register the 3 miners and ensure they are registered...
            for (int i = 0; i < 3; i++)
            {
                await fees1.RegisterMinerAsync(miners[i].ContractAddress);
            }

            Assert.Equal(3, await fees1.GetMinerCountAsync());

            for (int i = 0; i < 3; i++)
            {
                Assert.Equal(miners[i].ContractAddress, await fees1.GetMinerByIndexAsync(i));
            }

            // Remove the 2nd miner and check...
            await fees1.UnregisterMinerAsync(miners[1].ContractAddress);

            Assert.Equal(2, await fees1.GetMinerCountAsync());
            Assert.Equal(miners[0].ContractAddress, await fees1.GetMinerByIndexAsync(0));
            Assert.Equal(miners[2].ContractAddress, await fees1.GetMinerByIndexAsync(1));

            // Add the removed miner back...
            await fees1.RegisterMinerAsync(miners[1].ContractAddress);

            Assert.Equal(3, await fees1.GetMinerCountAsync());
            Assert.Equal(miners[0].ContractAddress, await fees1.GetMinerByIndexAsync(0));
            Assert.Equal(miners[2].ContractAddress, await fees1.GetMinerByIndexAsync(1));
            Assert.Equal(miners[1].ContractAddress, await fees1.GetMinerByIndexAsync(2));

            // Remove the latest miner...
            await fees1.UnregisterMinerAsync(miners[1].ContractAddress);

            Assert.Equal(2, await fees1.GetMinerCountAsync());
            Assert.Equal(miners[0].ContractAddress, await fees1.GetMinerByIndexAsync(0));
            Assert.Equal(miners[2].ContractAddress, await fees1.GetMinerByIndexAsync(1));
        }
예제 #14
0
        public async Task MineTest()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount = EthAccountFactory.Create();
            var systemAccount     = EthAccountFactory.Create();
            var coreTeamAccount   = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(systemAccount);

            await EthNetwork.Instance.RefillAsync(coreTeamAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create a fees...
            var fees1 = new AlgoFees(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await fees1.DeployAsync(token.ContractAddress);

            // Register the system account...
            await fees1.AddSystemAsync(systemAccount.Address);

            // Transfer some tokens to the fees...
            await token.TransferAsync(fees1.ContractAddress, 151.Algo());

            // Create one miner per category...
            var minerAccounts    = new IAccount[6];
            var referralAccounts = new IAccount[6];
            var miners           = new AlgoMiner[6];

            for (byte i = 0; i <= 5; i++)
            {
                // Create an account for the miner and the referral...
                minerAccounts[i]    = EthAccountFactory.Create();
                referralAccounts[i] = EthAccountFactory.Create();
                await EthNetwork.Instance.RefillAsync(minerAccounts[i]);

                // Create the miner as "NonPoolBased" so it can be activated...
                miners[i] = new AlgoMiner(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
                await miners[i].DeployAsync(1, i, minerAccounts[i].Address, referralAccounts[i].Address, token.ContractAddress);

                // Activate the miner...
                await miners[i].ActivateMinerAsync();

                // Start mining...
                {
                    var miner = new AlgoMiner(miners[i].ContractAddress, EthNetwork.Instance.GetWeb3(minerAccounts[i]), EthNetwork.Instance.GasPriceProvider);
                    await miner.StartMiningAsync();
                }

                // Register a miner...
                await fees1.RegisterMinerAsync(miners[i].ContractAddress);
            }

            // Mine the fees...
            {
                var fees = new AlgoFees(fees1.ContractAddress, EthNetwork.Instance.GetWeb3(systemAccount), EthNetwork.Instance.GasPriceProvider);
                await fees.MineAsync();
            }

            // Ensure the miners received the payment from the fees...
            var balance0 = await token.BalanceOfAsync(minerAccounts[0].Address);

            var balance1 = await token.BalanceOfAsync(minerAccounts[1].Address);

            var balance2 = await token.BalanceOfAsync(minerAccounts[2].Address);

            var balance3 = await token.BalanceOfAsync(minerAccounts[3].Address);

            var balance4 = await token.BalanceOfAsync(minerAccounts[4].Address);

            var balance5 = await token.BalanceOfAsync(minerAccounts[5].Address);

            Assert.Equal(1.Algo(), balance0);
            Assert.Equal(10.Algo(), balance1);
            Assert.Equal(20.Algo(), balance2);
            Assert.Equal(30.Algo(), balance3);
            Assert.Equal(40.Algo(), balance4);
            Assert.Equal(50.Algo(), balance5);
        }
예제 #15
0
        public async Task PoolBasedMinerBasicWorkfloWTest()
        {
            EthNetwork.UseDefaultTestNet();

            var prefundedAccount = new Account(EthNetwork.Instance.PrefundedPrivateKey);

            var tokenOwnerAccount = EthAccountFactory.Create();
            var systemAccount     = EthAccountFactory.Create();
            var coreTeamAccount   = EthAccountFactory.Create();
            var supervisorAccount = EthAccountFactory.Create();
            var minerAccount      = EthAccountFactory.Create();
            var referralAccount   = EthAccountFactory.Create();

            await EthNetwork.Instance.RefillAsync(tokenOwnerAccount);

            await EthNetwork.Instance.RefillAsync(systemAccount);

            await EthNetwork.Instance.RefillAsync(coreTeamAccount);

            await EthNetwork.Instance.RefillAsync(supervisorAccount);

            await EthNetwork.Instance.RefillAsync(minerAccount);

            // Create the ERC20 token...
            var token = new AlgoTokenV1(EthNetwork.Instance.GetWeb3(tokenOwnerAccount), EthNetwork.Instance.GasPriceProvider);
            await token.DeployAsync();

            // Create the pools to transfer the proper number of tokens to the miners...
            var pool1 = new AlgoPool(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await pool1.DeployAsync(0, token.ContractAddress);

            var pool2 = new AlgoPool(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await pool2.DeployAsync(1, token.ContractAddress);

            // Transfer some tokens to the pools...
            await token.TransferAsync(pool1.ContractAddress, 100.MAlgo());

            await token.TransferAsync(pool2.ContractAddress, 100.MAlgo());

            // Create a miner category 2...
            var miner1 = new AlgoMiner(EthNetwork.Instance.GetWeb3(coreTeamAccount), EthNetwork.Instance.GasPriceProvider);
            await miner1.DeployAsync(0, 2, minerAccount.Address, referralAccount.Address, token.ContractAddress);

            // Add roles to the miner...
            await miner1.AddSystemAsync(systemAccount.Address);

            await miner1.AddSupervisorAsync(supervisorAccount.Address);

            // Transfer tokens to the miner...
            await pool1.TransferToMinerAsync(miner1.ContractAddress);

            await pool2.TransferToMinerAsync(miner1.ContractAddress);

            // Ensure the miner received the tokens according to its category 2.
            Assert.Equal(2.MAlgo() + 2.MAlgo() * 10 / 100, await token.BalanceOfAsync(miner1.ContractAddress));

            // Activate the miner...
            await miner1.ActivateMinerAsync();

            // Start mining...
            miner1.Bind(EthNetwork.Instance.GetWeb3(minerAccount));
            await miner1.StartMiningAsync();

            // Mine 5 days...
            miner1.Bind(EthNetwork.Instance.GetWeb3(systemAccount));

            var        paymentPerDay           = 2.MAlgo() / 2 / 365;
            BigInteger expectedMinerBalance    = 0;
            BigInteger expectedReferralBalance = 0;

            for (int i = 0; i < 5; i++)
            {
                await miner1.MineAsync();

                expectedMinerBalance    += paymentPerDay;
                expectedReferralBalance += paymentPerDay * 10 / 100;

                Assert.Equal(expectedMinerBalance, await token.BalanceOfAsync(minerAccount.Address));
                Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));
            }

            // Pause the miner...
            miner1.Bind(EthNetwork.Instance.GetWeb3(supervisorAccount));
            await miner1.PauseMiningAsync();

            // Try to mine one day...
            miner1.Bind(EthNetwork.Instance.GetWeb3(systemAccount));
            await Assert.ThrowsAsync <TransactionRejectedException>(
                () => miner1.MineAsync());

            // Ensure the balance is not changed...
            Assert.Equal(expectedMinerBalance, await token.BalanceOfAsync(minerAccount.Address));

            // Resume the miner...
            miner1.Bind(EthNetwork.Instance.GetWeb3(supervisorAccount));
            await miner1.ResumeMiningAsync();

            // Mine one day...
            miner1.Bind(EthNetwork.Instance.GetWeb3(coreTeamAccount));
            await miner1.MineAsync();

            expectedMinerBalance    += paymentPerDay;
            expectedReferralBalance += paymentPerDay * 10 / 100;

            Assert.Equal(expectedMinerBalance, await token.BalanceOfAsync(minerAccount.Address));
            Assert.Equal(expectedReferralBalance, await token.BalanceOfAsync(referralAccount.Address));
        }
 public EnrollmentSystemActor()
 {
     Account = EthAccountFactory.Create();
     _web3   = new Web3(Account, EthTestNet.TESTNET_URL);
     Account.RefillAsync(1).Wait();
 }