Example #1
0
 public override void Deserialize(BinaryReader reader)
 {
     Version = reader.ReadUInt32();
     Inputs = reader.ReadSerializableArray<TransactionInput>();
     for (int i = 1; i < Inputs.Length; i++)
         for (int j = 0; j < i; j++)
             if (Inputs[i].PrevHash == Inputs[j].PrevHash && Inputs[i].PrevIndex == Inputs[j].PrevIndex)
                 throw new FormatException();
     Outputs = reader.ReadSerializableArray<TransactionOutput>();
     LockTime = reader.ReadUInt32();
 }
Example #2
0
 protected override void DeserializeExclusiveData(BinaryReader reader)
 {
     this.Enrollments = reader.ReadSerializableArray<UInt256>();
     if (Enrollments.Length == 0 || Enrollments.Length > 1024)
         throw new FormatException();
     if (Enrollments.Length != Enrollments.Distinct().Count())
         throw new FormatException();
 }
Example #3
0
 void ISignable.FromUnsignedArray(byte[] value)
 {
     using (MemoryStream ms = new MemoryStream(value, false))
     using (BinaryReader reader = new BinaryReader(ms))
     {
         this.AssetId = reader.ReadSerializable<UInt256>();
         this.ValueAssetId = reader.ReadSerializable<UInt256>();
         this.Agent = reader.ReadSerializable<UInt160>();
         this.Amount = reader.ReadSerializable<Fixed8>();
         this.Price = reader.ReadSerializable<Fixed8>();
         this.Client = reader.ReadSerializable<UInt160>();
         this.Inputs = reader.ReadSerializableArray<TransactionInput>();
     }
 }
Example #4
0
 private void DeserializeUnsignedInternal(BinaryReader reader, UInt256 asset_id, UInt256 value_asset_id, UInt160 agent)
 {
     AssetId = asset_id;
     ValueAssetId = value_asset_id;
     Agent = agent;
     Amount = reader.ReadSerializable<Fixed8>();
     if (Amount == Fixed8.Zero) throw new FormatException();
     if (Amount.GetData() % 10000 != 0) throw new FormatException();
     Price = reader.ReadSerializable<Fixed8>();
     if (Price <= Fixed8.Zero) throw new FormatException();
     if (Price.GetData() % 10000 != 0) throw new FormatException();
     Client = reader.ReadSerializable<UInt160>();
     Inputs = reader.ReadSerializableArray<TransactionInput>();
     if (Inputs.Distinct().Count() != Inputs.Length)
         throw new FormatException();
 }
 void ISignable.DeserializeUnsigned(BinaryReader reader)
 {
     PrevHash = reader.ReadSerializable<UInt256>();
     Miner = ECPoint.DeserializeFrom(reader, ECCurve.Secp256r1);
     IV = reader.ReadBytes(16);
     NoncePieces.Clear();
     int count = (int)reader.ReadVarInt();
     for (int i = 0; i < count; i++)
     {
         ECPoint key = ECPoint.DeserializeFrom(reader, ECCurve.Secp256r1);
         if (key == Miner) throw new FormatException();
         byte[] value = reader.ReadBytes((int)reader.ReadVarInt());
         NoncePieces.Add(key, value);
     }
     NonceHash = reader.ReadSerializable<UInt256>();
     TransactionHashes = reader.ReadSerializableArray<UInt256>();
 }
 public override void Deserialize(BinaryReader reader)
 {
     this.PrevHash = reader.ReadSerializable<UInt256>();
     this.Miner = Secp256r1Point.DeserializeFrom(reader);
     this.NoncePieces.Clear();
     int count = (int)reader.ReadVarInt();
     for (int i = 0; i < count; i++)
     {
         Secp256r1Point key = Secp256r1Point.DeserializeFrom(reader);
         if (key == Miner) throw new FormatException();
         byte[] value = reader.ReadBytes((int)reader.ReadVarInt());
         NoncePieces.Add(key, value);
     }
     this.NonceHash = reader.ReadSerializable<UInt256>();
     this.TransactionHashes = reader.ReadSerializableArray<UInt256>();
     this.Script = reader.ReadBytes((int)reader.ReadVarInt());
 }
Example #7
0
 private void DeserializeWithoutType(BinaryReader reader)
 {
     DeserializeExclusiveData(reader);
     this.Inputs = reader.ReadSerializableArray<TransactionInput>();
     if (GetAllInputs().Distinct().Count() != GetAllInputs().Count())
         throw new FormatException();
     this.Outputs = reader.ReadSerializableArray<TransactionOutput>();
     if (Outputs.Any(p => p.Value == Fixed8.Zero))
         throw new FormatException();
     this.Scripts = reader.ReadBytesArray();
 }
Example #8
0
 void ISignable.FromUnsignedArray(byte[] value)
 {
     using (MemoryStream ms = new MemoryStream(value, false))
     using (BinaryReader reader = new BinaryReader(ms))
     {
         if ((TransactionType)reader.ReadByte() != Type)
             throw new FormatException();
         DeserializeExclusiveData(reader);
         this.Inputs = reader.ReadSerializableArray<TransactionInput>();
         this.Outputs = reader.ReadSerializableArray<TransactionOutput>();
     }
 }
 protected override void DeserializeExclusiveData(BinaryReader reader)
 {
     this.Attributes = reader.ReadSerializableArray<TransactionAttribute>();
 }
Example #10
0
 internal static Transaction DeserializeFrom(BinaryReader reader)
 {
     TransactionType type = (TransactionType)reader.ReadByte();
     string typeName = string.Format("{0}.{1}", typeof(Transaction).Namespace, type);
     Transaction transaction = typeof(Transaction).Assembly.CreateInstance(typeName) as Transaction;
     if (transaction == null)
         throw new FormatException();
     transaction.DeserializeUnsignedWithoutType(reader);
     transaction.Scripts = reader.ReadSerializableArray<Script>();
     return transaction;
 }
Example #11
0
 private void DeserializeUnsignedWithoutType(BinaryReader reader)
 {
     DeserializeExclusiveData(reader);
     Attributes = reader.ReadSerializableArray<TransactionAttribute>();
     Inputs = reader.ReadSerializableArray<TransactionInput>();
     TransactionInput[] inputs = GetAllInputs().ToArray();
     for (int i = 1; i < inputs.Length; i++)
         for (int j = 0; j < i; j++)
             if (inputs[i].PrevHash == inputs[j].PrevHash && inputs[i].PrevIndex == inputs[j].PrevIndex)
                 throw new FormatException();
     Outputs = reader.ReadSerializableArray<TransactionOutput>();
     if (Outputs.Length > ushort.MaxValue + 1)
         throw new FormatException();
 }
 void ISignable.FromUnsignedArray(byte[] value)
 {
     using (MemoryStream ms = new MemoryStream(value, false))
     using (BinaryReader reader = new BinaryReader(ms))
     {
         this.PrevHash = reader.ReadSerializable<UInt256>();
         this.Miner = Secp256r1Point.DeserializeFrom(reader);
         this.NoncePieces.Clear();
         int count = (int)reader.ReadVarInt();
         for (int i = 0; i < count; i++)
         {
             Secp256r1Point key = Secp256r1Point.DeserializeFrom(reader);
             if (key == Miner) throw new FormatException();
             value = reader.ReadBytes((int)reader.ReadVarInt());
             NoncePieces.Add(key, value);
         }
         this.NonceHash = reader.ReadSerializable<UInt256>();
         this.TransactionHashes = reader.ReadSerializableArray<UInt256>();
     }
 }
Example #13
0
 internal void DeserializeInTransaction(BinaryReader reader, AgencyTransaction tx)
 {
     DeserializeUnsignedInternal(reader, tx.AssetId, tx.ValueAssetId, tx.Agent);
     Scripts = reader.ReadSerializableArray<Script>();
 }
Example #14
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     this.Headers = reader.ReadSerializableArray<BlockHeader>();
 }
Example #15
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     this.Version = reader.ReadUInt32();
     this.HashStart = reader.ReadSerializableArray<UInt256>();
     this.HashStop = reader.ReadSerializable<UInt256>();
 }
Example #16
0
 public LevelDBBlockchain(string path)
 {
     header_index.Add(GenesisBlock.Hash);
     Version version;
     Slice value;
     db = DB.Open(path, new Options { CreateIfMissing = true });
     if (db.TryGet(ReadOptions.Default, SliceBuilder.Begin(DataEntryPrefix.CFG_Version), out value) && Version.TryParse(value.ToString(), out version) && version >= Version.Parse("0.4"))
     {
         ReadOptions options = new ReadOptions { FillCache = false };
         value = db.Get(options, SliceBuilder.Begin(DataEntryPrefix.SYS_CurrentBlock));
         this.current_block_hash = new UInt256(value.ToArray().Take(32).ToArray());
         this.current_block_height = BitConverter.ToUInt32(value.ToArray(), 32);
         foreach (Block header in db.Find(options, SliceBuilder.Begin(DataEntryPrefix.DATA_HeaderList), (k, v) =>
         {
             using (MemoryStream ms = new MemoryStream(v.ToArray(), false))
             using (BinaryReader r = new BinaryReader(ms))
             {
                 return new
                 {
                     Index = BitConverter.ToUInt32(k.ToArray(), 1),
                     Headers = r.ReadSerializableArray<Block>()
                 };
             }
         }).OrderBy(p => p.Index).SelectMany(p => p.Headers).ToArray())
         {
             if (header.Hash != GenesisBlock.Hash)
             {
                 header_chain.Add(header.Hash, header, header.PrevBlock);
                 header_index.Add(header.Hash);
             }
             stored_header_count++;
         }
         if (stored_header_count == 0)
         {
             Dictionary<UInt256, Block> table = db.Find(options, SliceBuilder.Begin(DataEntryPrefix.DATA_Block), (k, v) => Block.FromTrimmedData(v.ToArray(), 0)).ToDictionary(p => p.PrevBlock);
             for (UInt256 hash = GenesisBlock.Hash; hash != current_block_hash;)
             {
                 Block header = table[hash];
                 header_chain.Add(header.Hash, header, header.PrevBlock);
                 header_index.Add(header.Hash);
                 hash = header.Hash;
             }
         }
         else if (current_block_height >= stored_header_count)
         {
             List<Block> list = new List<Block>();
             for (UInt256 hash = current_block_hash; hash != header_index[(int)stored_header_count - 1];)
             {
                 Block header = Block.FromTrimmedData(db.Get(options, SliceBuilder.Begin(DataEntryPrefix.DATA_Block).Add(hash)).ToArray(), 0);
                 list.Add(header);
                 header_index.Insert((int)stored_header_count, hash);
                 hash = header.PrevBlock;
             }
             for (int i = list.Count - 1; i >= 0; i--)
             {
                 header_chain.Add(list[i].Hash, list[i], list[i].PrevBlock);
             }
         }
         this.current_header_hash = header_index[header_index.Count - 1];
     }
     else
     {
         WriteBatch batch = new WriteBatch();
         ReadOptions options = new ReadOptions { FillCache = false };
         using (Iterator it = db.NewIterator(options))
         {
             for (it.SeekToFirst(); it.Valid(); it.Next())
             {
                 batch.Delete(it.Key());
             }
         }
         db.Write(WriteOptions.Default, batch);
         Persist(GenesisBlock);
         db.Put(WriteOptions.Default, SliceBuilder.Begin(DataEntryPrefix.CFG_Version), Assembly.GetExecutingAssembly().GetName().Version.ToString());
     }
     thread_persistence = new Thread(PersistBlocks);
     thread_persistence.Name = "LevelDBBlockchain.PersistBlocks";
     thread_persistence.Start();
     AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
 }
Example #17
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     HashStart = reader.ReadSerializableArray<UInt256>();
     HashStop = reader.ReadSerializable<UInt256>();
 }
Example #18
0
 public override void Deserialize(BinaryReader reader)
 {
     ((ISignable)this).DeserializeUnsigned(reader);
     Scripts = reader.ReadSerializableArray<Script>();
 }
Example #19
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     this.Headers = reader.ReadSerializableArray<Block>();
     if (Headers.Any(p => !p.IsHeader))
         throw new FormatException();
 }
Example #20
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     this.AddressList = reader.ReadSerializableArray<NetworkAddressWithTime>();
 }
Example #21
0
 void ISerializable.Deserialize(BinaryReader reader)
 {
     Inventories = reader.ReadSerializableArray<InventoryVector>();
 }