ReadVarInt() public static method

public static ReadVarInt ( BinaryReader br ) : ulong
br System.IO.BinaryReader
return ulong
Esempio n. 1
0
        void PH_Alert(byte[] payload)
        {
            MemoryStream stream = new MemoryStream(payload);
            BinaryReader br     = new BinaryReader(stream);
            UInt64       msgLen = Utils.ReadVarInt(br);
            string       msg    = Utils.ReadString(br, (int)msgLen);
            UInt64       sigLen = Utils.ReadVarInt(br);
            string       sig    = Utils.ReadString(br, (int)sigLen);

            Console.WriteLine("Alert: " + msg + " from: " + sig);
            br.Close();
        }
Esempio n. 2
0
        public void HandleHeadersPacket(NodeConnection from, byte[] payload)
        {
            MemoryStream stream = new MemoryStream(payload);
            BinaryReader br     = new BinaryReader(stream);

            List <BlockHeader> headers = new List <BlockHeader>();

            ulong count = Utils.ReadVarInt(br);

            Console.WriteLine("Got Headers: " + count);
            for (ulong i = 0; i < count; i++)
            {
                uint   version   = br.ReadUInt32();
                byte[] prevBlock = br.ReadBytes(32);
                byte[] merkle    = br.ReadBytes(32);
                uint   time      = br.ReadUInt32();
                uint   bits      = br.ReadUInt32();
                uint   nonce     = br.ReadUInt32();
                ulong  txn       = Utils.ReadVarInt(br);

                if (!mIgnoreSigLen)
                {
                    ulong siglen = Utils.ReadVarInt(br);
                    br.ReadBytes((int)siglen);
                }

                BlockHeader header = new BlockHeader(version, prevBlock, merkle, time, bits, nonce);
                if (headers.Count > 0)
                {
                    headers[headers.Count - 1].mHash = prevBlock;
                }
                headers.Add(header);
            }
            br.Close();

            if (!mPickedHashType)
            {
                mUseScryptHash  = headers[0].ValidateHash();
                mPickedHashType = true;
            }

            headers[headers.Count - 1].ComputeHash(mUseScryptHash);

            mPendingHeaders = headers;
            mLastNode       = from;
        }
Esempio n. 3
0
        void PH_Version(byte[] payload)
        {
            MemoryStream stream = new MemoryStream(payload);
            BinaryReader br     = new BinaryReader(stream);

            mRemoteVersion   = br.ReadUInt32();
            mRemoteServices  = br.ReadUInt64();
            mRemoteTimestamp = br.ReadUInt64();

            {
                //uint addrA_time = br.ReadUInt32();
                ulong  addrA_services = br.ReadUInt64();
                byte[] addrA_ip       = br.ReadBytes(16);
                ushort addrA_port     = br.ReadUInt16();
            }

            {
                //uint addrB_time = br.ReadUInt32();
                ulong  addrB_services = br.ReadUInt64();
                byte[] addrB_ip       = br.ReadBytes(16);
                ushort addrB_port     = br.ReadUInt16();
            }
            mRemoteNodeNOnce = br.ReadUInt64();

            ulong nameLen = Utils.ReadVarInt(br);

            char[] clientName = br.ReadChars((int)nameLen);
            mRemoteUserAgent = new string(clientName);

            mRemoteHeight = br.ReadUInt32();
            br.Close();

            // Send verack
            byte[] verackData = new byte[0];
            SendPacket("verack", verackData);

            mOwner.VersionRecieved(this);
            Console.WriteLine("Remote Version: " + mRemoteVersion);
        }
Esempio n. 4
0
        public void HandleBlockPacket(NodeConnection from, byte[] payload)
        {
            MemoryStream stream = new MemoryStream(payload);
            BinaryReader br     = new BinaryReader(stream);

            uint version = br.ReadUInt32();

            byte[] prevBlock = br.ReadBytes(32);
            byte[] merkle    = br.ReadBytes(32);
            uint   time      = br.ReadUInt32();
            uint   bits      = br.ReadUInt32();
            uint   nonce     = br.ReadUInt32();
            ulong  txn       = Utils.ReadVarInt(br);

            BlockHeader h = new BlockHeader(version, prevBlock, merkle, time, bits, nonce);

            h.ComputeHash(mUseScryptHash);

            Block block = FindBlock(h.mHash);

            if (block == null)
            {
                // Create a new block
                string hash = Utils.ByteArrayToHexString(h.mHash);
                Console.WriteLine("does a new block ever get introduced this way!?? " + hash);
                return;
            }

            block.mTransactions.Clear();
            for (ulong j = 0; j < txn; j++)
            {
                Transaction tx = new Transaction();
                tx.mVersion = br.ReadUInt32();
                if (mTransactionTimeStamp)
                {
                    tx.mTimestamp = br.ReadUInt32();
                }

                ulong inCount = Utils.ReadVarInt(br);
                for (ulong k = 0; k < inCount; k++)
                {
                    TransactionInput ti = new TransactionInput();
                    ti.mPrevOuptutHash  = br.ReadBytes(32);
                    ti.mPrevOutputIndex = br.ReadUInt32();

                    ulong scriptLen = Utils.ReadVarInt(br);
                    ti.mScript = br.ReadBytes((int)scriptLen);

                    ti.mSequence = br.ReadUInt32();

                    tx.mInputs.Add(ti);
                }

                ulong outCount = Utils.ReadVarInt(br);
                for (ulong k = 0; k < outCount; k++)
                {
                    TransactionOutput to = new TransactionOutput();
                    to.mValue     = br.ReadUInt64();
                    to.mRealValue = (double)to.mValue / 1000000.0;

                    ulong scriptLen = Utils.ReadVarInt(br);
                    to.mScript = br.ReadBytes((int)scriptLen);

                    tx.mOutputs.Add(to);
                }
                tx.mLockTime = br.ReadUInt32();
                if (tx.mVersion > 1)
                {
                    ulong commentLen = Utils.ReadVarInt(br);
                    tx.mComment = br.ReadBytes((int)commentLen);
                }

                block.mTransactions.Add(tx);
            }
            br.Close();
        }