Esempi in C# (CSharp) per PrivateKeyAccount.GenerateSeed

Esempio n. 1

File: AliasTest.cs Progetto: cryptoneobancoin/BancoinCS

        public void TestTransferToAlias()
        {
            var node = new Node(Node.TestNetChainId);

            var seed    = PrivateKeyAccount.GenerateSeed();
            var account = PrivateKeyAccount.CreateFromSeed(seed, 'T');

            var response = node.Transfer(Accounts.Alice, account.Address, Assets.BCT, 0.001m);

            node.WaitTransactionConfirmationByResponse(response);

            var alias = GenerateRandomAlias();

            response = node.CreateAlias(account, alias, 'T');
            node.WaitTransactionConfirmationByResponse(response);

            var amount        = 0.0001m;
            var balanceBefore = node.GetBalance(account.Address);

            response = node.Transfer(Accounts.Alice, "alias:T:" + alias, Assets.BCT, amount);
            node.WaitTransactionConfirmationByResponse(response);

            var balanceAfter = node.GetBalance(account.Address);

            Assert.AreEqual(balanceBefore + amount, balanceAfter);
        }

Esempio n. 2

        public void TestTransferToAlias()
        {
            var node = new Node(Node.TestNetHost);

            var seed    = PrivateKeyAccount.GenerateSeed();
            var account = PrivateKeyAccount.CreateFromSeed(seed, 'T');

            node.Transfer(Accounts.Alice, account.Address, Assets.WAVES, 0.001m);
            Thread.Sleep(10000);

            var alias = GenerateRandomAlias();

            node.CreateAlias(account, alias, 'T');
            Thread.Sleep(10000);

            var amount        = 0.0001m;
            var balanceBefore = node.GetBalance(account.Address);

            node.Transfer(Accounts.Alice, "alias:T:" + alias, Assets.WAVES, amount);
            Thread.Sleep(15000);

            var balanceAfter = node.GetBalance(account.Address);

            Assert.AreEqual(balanceBefore + amount, balanceAfter);
        }

Esempio n. 3

File: MainViewModel.cs Progetto: RVShershnev/Waves-wallet

 public void Init()
 {
     Seed             = PrivateKeyAccount.GenerateSeed();
     Account          = PrivateKeyAccount.CreateFromSeed(seed, AddressEncoding.TestNet);
     Base58PrivateKey = Account.PrivateKey.ToBase58();
     Base58PublicKey  = Account.PublicKey.ToBase58();
 }

Esempio n. 4

File: AccountTest.cs Progetto: eoliveros/xchwallet

        public void TestSeedGeneration()
        {
            string seed = PrivateKeyAccount.GenerateSeed();
            Assert.AreEqual(15, seed.Split(' ').Length);

            seed = PrivateKeyAccount.GenerateSeed();
            Assert.AreEqual(15, seed.Split(' ').Length);
        }

Esempio n. 5

        public void TestMultisig()
        {
            // This test works with tranfer transactions of version 2 only
            var node = new Node();

            var script = $@"                
                let aliceSigned = sigVerify(tx.bodyBytes, tx.proofs[0], base58'{Accounts.Alice.PublicKey.ToBase58()}')
                let bobSigned   = sigVerify(tx.bodyBytes, tx.proofs[1], base58'{Accounts.Bob.PublicKey.ToBase58()}')
                aliceSigned && bobSigned";

            Console.WriteLine($"Script: {script}");

            var compiledScript = node.CompileScript(script);

            var multiAccount = PrivateKeyAccount.CreateFromSeed(PrivateKeyAccount.GenerateSeed(), AddressEncoding.TestNet);

            Console.WriteLine("Account generated: {0}", multiAccount.Address);
            node.Transfer(Accounts.Alice, multiAccount.Address, Assets.WAVES, 0.1m);

            Thread.Sleep(10000);

            Assert.IsTrue(node.GetBalance(multiAccount.Address) == 0.1m);

            var setScriptTx = new SetScriptTransaction(multiAccount.PublicKey, compiledScript, 'T');

            setScriptTx.Sign(multiAccount);
            node.Broadcast(setScriptTx.GetJsonWithSignature());

            Thread.Sleep(10000);

            var tx = new TransferTransaction(multiAccount.PublicKey, Accounts.Alice.Address, Assets.WAVES, 0.07m, 0.005m)
            {
                Version = 2
            };

            tx.Sign(Accounts.Alice, 0);
            tx.Sign(Accounts.Bob, 1);

            node.Broadcast(tx);

            Thread.Sleep(10000);

            Assert.IsTrue(node.GetBalance(multiAccount.Address) < 0.02m);
        }

Esempio n. 6

        public void TestMultisig()
        {
            // This test works with transfer transactions of version 2 only
            var node = new Node();

            var script = $@"                
                let aliceSigned = sigVerify(tx.bodyBytes, tx.proofs[0], base58'{Accounts.Alice.PublicKey.ToBase58()}')
                let bobSigned   = sigVerify(tx.bodyBytes, tx.proofs[1], base58'{Accounts.Bob.PublicKey.ToBase58()}')
                aliceSigned && bobSigned";

            Console.WriteLine($"Script: {script}");

            var compiledScript = node.CompileScript(script);

            var multiAccount = PrivateKeyAccount.CreateFromSeed(PrivateKeyAccount.GenerateSeed(), AddressEncoding.TestNet);

            Console.WriteLine("Account generated: {0}", multiAccount.Address);

            var response = node.Transfer(Accounts.Alice, multiAccount.Address, Assets.ZBS, 0.1m);

            node.WaitForTransactionBroadcastResponseConfirmation(response);

            Assert.IsTrue(node.GetBalance(multiAccount.Address) == 0.1m);

            response = node.SetScript(multiAccount, compiledScript, node.ChainId);
            node.WaitForTransactionBroadcastResponseConfirmation(response);

            var tx = new TransferTransaction(node.ChainId, multiAccount.PublicKey, Accounts.Alice.Address, Assets.ZBS, 0.07m, 0.005m)
            {
                Version = 2
            };

            tx.Sign(Accounts.Alice, 0);
            tx.Sign(Accounts.Bob, 1);

            node.BroadcastAndWait(tx);

            Assert.IsTrue(node.GetBalance(multiAccount.Address) < 0.02m);
        }

Esempio n. 7

        public void TestMassTransferToAlias()
        {
            var node = new Node(Node.TestNetHost);

            var seed    = PrivateKeyAccount.GenerateSeed();
            var account = PrivateKeyAccount.CreateFromSeed(seed, 'T');

            node.Transfer(Accounts.Alice, account.Address, Assets.WAVES, 0.001m);
            Thread.Sleep(10000);

            var alias = GenerateRandomAlias();

            node.CreateAlias(account, alias, 'T');
            Thread.Sleep(10000);

            var amount        = 0.0001m;
            var balanceBefore = node.GetBalance(account.Address);

            var recipients = new List <MassTransferItem>
            {
                new MassTransferItem(account.Address, amount),
                new MassTransferItem("alias:T:" + alias, amount),
                new MassTransferItem(account.Address, amount),
                new MassTransferItem(account.Address, amount),
                new MassTransferItem("alias:T:" + alias, amount)
            };

            var tx = new MassTransferTransaction(Accounts.Alice.PublicKey, Assets.WAVES, recipients);

            tx.Sign(Accounts.Alice);
            node.Broadcast(tx.GetJsonWithSignature());

            Thread.Sleep(20000);

            var balanceAfter = node.GetBalance(account.Address);

            Assert.AreEqual(balanceBefore + amount * recipients.Count, balanceAfter);
        }

Esempio n. 8

File: AliasTest.cs Progetto: cryptoneobancoin/BancoinCS

        public void TestMassTransferToAlias()
        {
            var node = new Node(Node.TestNetChainId);

            var seed    = PrivateKeyAccount.GenerateSeed();
            var account = PrivateKeyAccount.CreateFromSeed(seed, 'T');

            var response = node.Transfer(Accounts.Alice, account.Address, Assets.BCT, 0.001m);

            node.WaitTransactionConfirmationByResponse(response);

            var alias = GenerateRandomAlias();

            response = node.CreateAlias(account, alias, 'T');
            node.WaitTransactionConfirmationByResponse(response);

            var amount        = 0.0001m;
            var balanceBefore = node.GetBalance(account.Address);

            var recipients = new List <MassTransferItem>
            {
                new MassTransferItem(account.Address, amount),
                new MassTransferItem("alias:T:" + alias, amount),
                new MassTransferItem(account.Address, amount),
                new MassTransferItem(account.Address, amount),
                new MassTransferItem("alias:T:" + alias, amount)
            };

            var tx = new MassTransferTransaction(node.ChainId, Accounts.Alice.PublicKey, Assets.BCT, recipients);

            tx.Sign(Accounts.Alice);
            node.BroadcastAndWait(tx.GetJsonWithSignature());

            var balanceAfter = node.GetBalance(account.Address);

            Assert.AreEqual(balanceBefore + amount * recipients.Count, balanceAfter);
        }

Esempio n. 9

        public void TestErrorMessage()
        {
            var node    = new Node(Node.TestNetChainId);
            var account = PrivateKeyAccount.CreateFromSeed(PrivateKeyAccount.GenerateSeed(), node.ChainId);

            var transferTxResponse = node.Transfer(Accounts.Alice, account.Address, Assets.WAVES, 0.02m);

            node.WaitTransactionConfirmationByResponse(transferTxResponse);

            var script = @"{-# STDLIB_VERSION 3 #-}
{-# CONTENT_TYPE DAPP #-}
{-# SCRIPT_TYPE ACCOUNT #-}

@Verifier(tx)
func verify() = {
    match tx {
        case d: SetScriptTransaction | DataTransaction => true
        case _ => false
    }
}";

            var compiledScript = node.CompileCode(script);

            var setScriptTxResponse = node.SetScript(account, compiledScript);

            node.WaitTransactionConfirmationByResponse(setScriptTxResponse);

            try
            {
                node.Transfer(account, account.Address, Assets.WAVES, 0.00000001m, 0.005m);
            }
            catch (Exception e)
            {
                Console.WriteLine($"Error: {e.Message}");
                Assert.AreEqual(e.Message, "Transaction is not allowed by account-script");
            }
        }