Beispiel #1
0
        public static List <Hash> FilterNewHashes(TransactionHashList transactions, List <Hash> storedHashes)
        {
            var newHashes = new List <Hash>();

            foreach (var transactionsHash in transactions.Hashes)
            {
                var isStored = false;
                foreach (var storedHash in storedHashes)
                {
                    if (transactionsHash.Value != storedHash.Value)
                    {
                        continue;
                    }

                    isStored = true;
                    break;
                }

                if (!isStored)
                {
                    newHashes.Add(transactionsHash);
                }
            }

            return(newHashes);
        }
Beispiel #2
0
        private static void GetFromChain(string address, RestIotaRepository repository)
        {
            int depth = 3;
            int minWeightMagnitude = 9;

            try
            {
                TransactionHashList transactionsByAdress =
                    repository.FindTransactionsByAddresses(new List <Address> {
                    new Address(address)
                });

                List <TransactionTrytes> transactionsTrytesList = repository.GetTrytes(transactionsByAdress.Hashes);

                Dictionary <int, Transaction> transactionPosition = new Dictionary <int, Transaction>();
                int lastIndex = 0;
                //foreach (Hash hash in transactionsByAdress.Hashes)
                //{
                foreach (TransactionTrytes transactionTrytes in transactionsTrytesList)
                {
                    Transaction transactionOne = Transaction.FromTrytes(transactionTrytes, transactionsByAdress.Hashes[0]);
                    transactionPosition.Add(transactionOne.CurrentIndex, transactionOne);
                    lastIndex = transactionOne.LastIndex;
                }
                //}

                string combined = string.Empty;
                for (int i = 0; i < lastIndex; i++)
                {
                    combined += transactionPosition[i].Fragment.Value;
                }

                string fertisch = TrytesToString(combined);
                Console.WriteLine(fertisch + " positiv");
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
                //throw;
            }

            //Hash hashAddress = new Hash(transactionsByAdress.Hashes[0].Value);
            //TransactionHashList bundleTransactions = repository.FindTransactionsByBundles(new List<Hash> {bundle.Hash});
            //foreach (Hash transactionsHash in bundleTransactions.Hashes)
            //{
            //    Hash hash = new Hash(transactionsHash.Value);
            //    var transactionsTrytes = repository.GetTrytes(bundleTransactions.Hashes);
            //    var transaction = Transaction.FromTrytes(transactionsTrytes[0], hash);
            //}
        }
Beispiel #3
0
        private static void SendToChain(string address, RestIotaRepository repository, string message)
        {
            Seed     seed     = new Seed(address);
            Transfer transfer = new Transfer
            {
                Address         = new Address(address),
                Message         = TryteString.FromUtf8String(message),
                ValueToTransfer = 0
            };

            Bundle bundle = new Bundle();

            bundle.AddTransfer(transfer);


            int depth = 3;
            int minWeightMagnitude = 9;

            try
            {
                var sendTransfer = repository.SendTransfer(seed, bundle, SecurityLevel.Medium, depth, minWeightMagnitude);

                //TransactionHashList bundleTransactions = repository.FindTransactionsByBundles(new List<Hash> {bundle.Hash});
                //foreach (Hash transactionsHash in bundleTransactions.Hashes)
                //{
                //    Hash hash = new Hash(transactionsHash.Value);
                //    var transactionsTrytes = repository.GetTrytes(bundleTransactions.Hashes);
                //    var transaction = Transaction.FromTrytes(transactionsTrytes[0], hash);
                //}

                TransactionHashList transactionsByAdress =
                    repository.FindTransactionsByAddresses(new List <Address> {
                    new Address(address)
                });

                var  transactionsTrytesAddress = repository.GetTrytes(transactionsByAdress.Hashes).First();
                Hash hashAddress = new Hash(transactionsByAdress.Hashes[0].Value);

                Transaction       transactionOne    = Transaction.FromTrytes(transactionsTrytesAddress, hashAddress);
                TransactionTrytes transactionTrytes = new TransactionTrytes("");
                TransactionTrytes test = transactionOne.ToTrytes();
                var text = test.Value;
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
                //throw;
            }
        }
Beispiel #4
0
        public PositionEncrypted GetPosition(string address)
        {
            int depth = 3;
            int minWeightMagnitude = 9;
            PositionEncrypted positionEncrypted = new PositionEncrypted();

            try
            {
                TransactionHashList transactionsByAdress =
                    _Repository.FindTransactionsByAddresses(new List <Address> {
                    new Address(address)
                });

                List <TransactionTrytes> transactionsTrytesList = _Repository.GetTrytes(transactionsByAdress.Hashes);

                Dictionary <int, Transaction> transactionPosition = new Dictionary <int, Transaction>();
                int lastIndex = 0;
                foreach (TransactionTrytes transactionTrytes in transactionsTrytesList)
                {
                    Transaction transactionOne = Transaction.FromTrytes(transactionTrytes, transactionsByAdress.Hashes[0]);
                    transactionPosition.Add(transactionOne.CurrentIndex, transactionOne);
                    lastIndex = transactionOne.LastIndex;
                }

                string combined = string.Empty;
                for (int i = 0; i <= lastIndex; i++)
                {
                    combined += transactionPosition[i].Fragment.Value;
                }

                string   fertisch = TrytesToString(combined);
                string[] lines    = fertisch.Split(new[] { "#" }, StringSplitOptions.None);

                positionEncrypted     = new PositionEncrypted();
                positionEncrypted.Lon = new Ciphertext();
                positionEncrypted.Lon.Load(new MemoryStream(Convert.FromBase64String(lines[0])));

                positionEncrypted.Lat = new Ciphertext();
                positionEncrypted.Lat.Load(new MemoryStream(Convert.FromBase64String(lines[1])));
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception);
                //throw;
            }

            return(positionEncrypted);
        }