public void ReadWrite(BitcoinStream stream) { if (stream.Serializing) { stream.ReadWriteAsVarInt(ref this.height); stream.ReadWrite(ref this.isCoinbase); stream.ReadWrite(ref this.isCoinstake); stream.ReadWrite(ref this.time); stream.ReadWrite(ref this.txOut); // var compressedTx = new TxOutCompressor(this.txOut); // stream.ReadWrite(ref compressedTx); } else { stream.ReadWriteAsVarInt(ref this.height); stream.ReadWrite(ref this.isCoinbase); stream.ReadWrite(ref this.isCoinstake); stream.ReadWrite(ref this.time); stream.ReadWrite(ref this.txOut); // var compressed = new TxOutCompressor(); // stream.ReadWrite(ref compressed); // this.txOut = compressed.TxOut; } }
public override void ReadWrite(BitcoinStream stream) { stream.ReadWriteAsVarInt(ref TxType); stream.ReadWriteAsVarInt(ref Version); stream.ReadWriteAsCompactVarInt(ref ValidHeight); stream.ReadWrite(ref RegId); stream.ReadWrite(ref Script); stream.ReadWriteAsCompactVarInt(ref Fees); stream.ReadWrite(ref Signature); }
public static void ReadWriteC(this BitcoinStream bs, ref Money[][] arr) { if (bs.Serializing) { if (arr == null) { uint o = 0; bs.ReadWriteAsVarInt(ref o); return; } var len = (uint)arr.Length; bs.ReadWriteAsVarInt(ref len); for (int i = 0; i < len; i++) { var subLen = (uint)arr[i].Length; bs.ReadWriteAsVarInt(ref subLen); for (int j = 0; j < subLen; j++) { var n = arr[i][j]; bs.ReadWriteC(ref n); } } } else { uint len = 0; bs.ReadWriteAsVarInt(ref len); if (len == 0) { arr = null; return; } if (len > bs.MaxArraySize) { throw new ArgumentOutOfRangeException("Array is too big"); } arr = new Money[len][]; for (int i = 0; i < len; i++) { uint subLen = 0; bs.ReadWriteAsVarInt(ref subLen); if (subLen == 0) { arr[i] = null; return; } arr[i] = new Money[subLen]; for (int j = 0; j < subLen; j++) { bs.ReadWriteC(ref arr[i][j]); } } } }
public override void ReadWrite(BitcoinStream stream) { stream.ReadWriteAsVarInt(ref TxType); stream.ReadWriteAsVarInt(ref Version); stream.ReadWriteAsCompactVarInt(ref ValidHeight); stream.ReadWrite(ref SrcId); stream.ReadWrite(ref DesId); stream.ReadWriteAsCompactVarInt(ref Fees); stream.ReadWriteAsCompactVarInt(ref Values); stream.ReadWrite(ref Contract); stream.ReadWrite(ref Signature); }
protected virtual void BuildCoinbase() { var sigScriptInitial = GenerateScriptSigInitial(); var sigScriptInitialBytes = sigScriptInitial.ToBytes(); var sigScriptLength = (uint)( sigScriptInitial.Length + extraNoncePlaceHolderLength + scriptSigFinalBytes.Length); txOut = CreateOutputTransaction(); using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref txVersion); if (isPoS) { var timestamp = BlockTemplate.CurTime; bs.ReadWrite(ref timestamp); } bs.ReadWriteAsVarInt(ref txInputCount); bs.ReadWrite(ref sha256Empty); bs.ReadWrite(ref txInPrevOutIndex); bs.ReadWriteAsVarInt(ref sigScriptLength); bs.ReadWrite(ref sigScriptInitialBytes); coinbaseInitial = stream.ToArray(); coinbaseInitialHex = coinbaseInitial.ToHexString(); } using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref scriptSigFinalBytes); bs.ReadWrite(ref txInSequence); var txOutBytes = SerializeOutputTransaction(txOut); bs.ReadWrite(ref txOutBytes); bs.ReadWrite(ref txLockTime); coinbaseFinal = stream.ToArray(); coinbaseFinalHex = coinbaseFinal.ToHexString(); } }
public override uint256 GetSignatureHash() { BitcoinStream stream = CreateHashWriter(HashVersion.Original); stream.ReadWriteAsVarInt(ref Version); stream.ReadWriteAsVarInt(ref TxType); stream.ReadWriteAsCompactVarInt(ref ValidHeight); stream.ReadWrite(ref RegId); stream.ReadWrite(ref Script); stream.ReadWriteAsCompactVarInt(ref Fees); return(GetHash(stream)); }
private byte[] SerializeOutputTransaction(Transaction tx) { var withDefaultWitnessCommitment = !string.IsNullOrEmpty(BlockTemplate.DefaultWitnessCommitment); var outputCount = (uint)tx.Outputs.Count; if (withDefaultWitnessCommitment) { outputCount++; } using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); // write output count bs.ReadWriteAsVarInt(ref outputCount); long amount; byte[] raw; uint rawLength; // serialize witness (segwit) if (withDefaultWitnessCommitment) { amount = 0; raw = BlockTemplate.DefaultWitnessCommitment.HexToByteArray(); rawLength = (uint)raw.Length; bs.ReadWrite(ref amount); bs.ReadWriteAsVarInt(ref rawLength); bs.ReadWrite(ref raw); } // serialize outputs foreach (var output in tx.Outputs) { amount = output.Value.Satoshi; var outScript = output.ScriptPubKey; raw = outScript.ToBytes(true); rawLength = (uint)raw.Length; bs.ReadWrite(ref amount); bs.ReadWriteAsVarInt(ref rawLength); bs.ReadWrite(ref raw); } return(stream.ToArray()); } }
public override void ReadWriteCore(BitcoinStream stream) { stream.ReadWrite(ref this.blockId); ulong indexes_size = (ulong)this.indices.Count; stream.ReadWriteAsVarInt(ref indexes_size); if (!stream.Serializing) { ulong i = 0; ulong indicesCount = 0; while ((ulong)this.indices.Count < indexes_size) { indicesCount = Math.Min(1000UL + (ulong)indicesCount, (ulong)indexes_size); for (; i < indicesCount; i++) { ulong index = 0; stream.ReadWriteAsVarInt(ref index); if (index > int.MaxValue) { throw new FormatException("indexes overflowed 31-bits"); } this.indices.Add((int)index); } } int offset = 0; for (int ii = 0; ii < this.indices.Count; ii++) { if ((ulong)(this.indices[ii]) + (ulong)(offset) > int.MaxValue) { throw new FormatException("indexes overflowed 31-bits"); } this.indices[ii] = this.indices[ii] + offset; offset = this.indices[ii] + 1; } } else { for (int i = 0; i < this.indices.Count; i++) { int index = this.indices[i] - (i == 0 ? 0 : (this.indices[i - 1] + 1)); stream.ReadWrite(ref index); } } }
public void ReadWrite(BitcoinStream stream) { stream.ReadWriteAsVarInt(ref _OutputIndex); stream.ReadWrite(ref _Transaction); stream.ReadWrite(ref _MerkleProof); stream.ReadWriteC(ref _EscrowInitiatorKey); }
private bool ReadScript(Script script) { try { var data = TxNullDataTemplate.Instance.ExtractScriptPubKeyParameters(script); if(data == null) return false; BitcoinStream stream = new BitcoinStream(data); ushort marker = 0; stream.ReadWrite(ref marker); if(marker != Tag) return false; stream.ReadWrite(ref _Version); if(_Version != 1) return false; ulong quantityCount = 0; stream.ReadWriteAsVarInt(ref quantityCount); Quantities = new ulong[quantityCount]; for(ulong i = 0 ; i < quantityCount ; i++) { Quantities[i] = ReadLEB128(stream); if(Quantities[i] > MAX_QUANTITY) return false; } stream.ReadWriteAsVarString(ref _Metadata); return true; } catch(Exception) { return false; } }
protected override void BuildCoinbase() { var script = TxIn.CreateCoinbase((int) BlockTemplate.Height).ScriptSig; txOut = CreateOutputTransaction(); using(var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref txVersion); bs.ReadWriteAsVarInt(ref txInputCount); bs.ReadWrite(ref sha256Empty); bs.ReadWrite(ref coinbaseIndex); bs.ReadWrite(ref script); bs.ReadWrite(ref coinbaseSequence); var txOutBytes = SerializeOutputTransaction(txOut); bs.ReadWrite(ref txOutBytes); bs.ReadWrite(ref txLockTime); coinbaseInitial = stream.ToArray(); coinbaseInitialHex = coinbaseInitial.ToHexString(); coinbaseInitialHash = sha256D.Digest(coinbaseInitial); } }
private static void WriteScriptCode(BitcoinStream stream, Script scriptCode) { int nCodeSeparators = 0; var reader = scriptCode.CreateReader(); OpcodeType opcode; while (reader.TryReadOpCode(out opcode)) { if (opcode == OpcodeType.OP_CODESEPARATOR) { nCodeSeparators++; } } uint n = (uint)(scriptCode.Length - nCodeSeparators); stream.ReadWriteAsVarInt(ref n); reader = scriptCode.CreateReader(); int itBegin = 0; while (reader.TryReadOpCode(out opcode)) { if (opcode == OpcodeType.OP_CODESEPARATOR) { stream.Inner.Write(scriptCode.ToBytes(true), itBegin, (int)(reader.Inner.Position - itBegin - 1)); itBegin = (int)reader.Inner.Position; } } if (itBegin != scriptCode.Length) { stream.Inner.Write(scriptCode.ToBytes(true), itBegin, (int)(reader.Inner.Position - itBegin)); } }
protected override void BuildCoinbase() { var script = TxIn.CreateCoinbase((int)BlockTemplate.Height).ScriptSig; // output transaction txOut = CreateOutputTransaction(); using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); // version bs.ReadWrite(ref txVersion); // serialize (simulated) input transaction bs.ReadWriteAsVarInt(ref txInputCount); bs.ReadWrite(ref sha256Empty); bs.ReadWrite(ref coinbaseIndex); bs.ReadWrite(ref script); bs.ReadWrite(ref coinbaseSequence); // serialize output transaction var txOutBytes = SerializeOutputTransaction(txOut); bs.ReadWrite(ref txOutBytes); // misc bs.ReadWrite(ref txLockTime); // done coinbaseInitial = stream.ToArray(); coinbaseInitialHash = new byte[32]; sha256D.Digest(coinbaseInitial, coinbaseInitialHash); } }
private bool ReadData(byte[] data) { try { BitcoinStream stream = new BitcoinStream(data); ushort marker = 0; stream.ReadWrite(ref marker); if(marker != Tag) return false; stream.ReadWrite(ref _Version); if(_Version != 1) return false; ulong quantityCount = 0; stream.ReadWriteAsVarInt(ref quantityCount); Quantities = new ulong[quantityCount]; for(ulong i = 0 ; i < quantityCount ; i++) { Quantities[i] = ReadLEB128(stream); if(Quantities[i] > MAX_QUANTITY) return false; } stream.ReadWriteAsVarString(ref _Metadata); if(stream.Inner.Position != data.Length) return false; return true; } catch(Exception) { return false; } }
public QuorumCommitment(BinaryReader data) { QfcVersion = data.ReadUInt16(); LlmqType = data.ReadByte(); QuorumHash = new uint256(data.ReadBytes(SpecialTransaction.SHA256_HASH_SIZE)); var bs = new BitcoinStream(data.BaseStream, false); bs.ReadWriteAsVarInt(ref SignersSize); Signers = data.ReadBytes(((int)SignersSize + 7) / 8); bs.ReadWriteAsVarInt(ref ValidMembersSize); ValidMembers = data.ReadBytes(((int)ValidMembersSize + 7) / 8); QuorumPublicKey = data.ReadBytes(SpecialTransaction.BLS_PUBLIC_KEY_SIZE); QuorumVvecHash = new uint256(data.ReadBytes(SpecialTransaction.SHA256_HASH_SIZE)); QuorumSig = data.ReadBytes(SpecialTransaction.BLS_SIGNATURE_SIZE); Sig = data.ReadBytes(SpecialTransaction.BLS_SIGNATURE_SIZE); }
protected virtual byte[] SerializeBlock(byte[] header, byte[] coinbase) { var transactionCount = (uint)BlockTemplate.Transactions.Length + 1; // +1 for prepended coinbase tx var rawTransactionBuffer = BuildRawTransactionBuffer(); using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref header); bs.ReadWriteAsVarInt(ref transactionCount); bs.ReadWrite(ref coinbase); bs.ReadWrite(ref rawTransactionBuffer); // TODO: handle DASH coin masternode_payments // POS coins require a zero byte appended to block which the daemon replaces with the signature if (isPoS) { bs.ReadWrite((byte)0); } return(stream.ToArray()); } }
public static void ReadWriteC(this BitcoinStream bs, ref PoupardSternProof proof) { if (bs.Serializing) { if (proof == null) { uint o = 0; bs.ReadWriteAsVarInt(ref o); return; } var len = (uint)proof.XValues.Length; bs.ReadWriteAsVarInt(ref len); for (int i = 0; i < len; i++) { var n = proof.XValues[i]; bs.ReadWriteC(ref n); } var yvalue = proof.YValue; bs.ReadWriteC(ref yvalue); } else { uint len = 0; bs.ReadWriteAsVarInt(ref len); if (len == 0) { proof = null; return; } if (len > bs.MaxArraySize) { throw new ArgumentOutOfRangeException("Array is too big"); } var xValues = new NTumbleBit.BouncyCastle.Math.BigInteger[len]; for (int i = 0; i < len; i++) { NTumbleBit.BouncyCastle.Math.BigInteger b = null; bs.ReadWriteC(ref b); xValues[i] = b; } NTumbleBit.BouncyCastle.Math.BigInteger yValue = null; bs.ReadWriteC(ref yValue); proof = new PoupardSternProof(Tuple.Create(xValues, yValue)); } }
public static void ReadWriteC(this BitcoinStream bs, ref PermutationTestProof proof) { if (bs.Serializing) { if (proof == null) { uint o = 0; bs.ReadWriteAsVarInt(ref o); return; } var len = (uint)proof.Signatures.Length; bs.ReadWriteAsVarInt(ref len); for (int i = 0; i < len; i++) { var sig = proof.Signatures[i]; bs.ReadWriteAsVarString(ref sig); } } else { uint len = 0; bs.ReadWriteAsVarInt(ref len); if (len == 0) { proof = null; return; } if (len > bs.MaxArraySize) { throw new ArgumentOutOfRangeException("Array is too big"); } var signatures = new byte[len][]; for (int i = 0; i < len; i++) { byte[] sig = null; bs.ReadWriteAsVarString(ref sig); signatures[i] = sig; } proof = new PermutationTestProof(signatures); } }
public ProviderRegistrationTransaction(byte[] extraPayload) : base(extraPayload) { Type = data.ReadUInt16(); Mode = data.ReadUInt16(); CollateralHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); CollateralIndex = data.ReadUInt32(); IpAddress = data.ReadBytes(IpAddressLength); Port = BitConverter.ToUInt16(data.ReadBytes(2).Reverse().ToArray(), 0); KeyIdOwner = new uint160(data.ReadBytes(PUBKEY_ID_SIZE), true); KeyIdOperator = data.ReadBytes(BLS_PUBLIC_KEY_SIZE); KeyIdVoting = new uint160(data.ReadBytes(PUBKEY_ID_SIZE), true); OperatorReward = data.ReadUInt16(); var bs = new BitcoinStream(data.BaseStream, false); bs.ReadWriteAsVarInt(ref ScriptPayoutSize); ScriptPayout = new Script(data.ReadBytes((int)ScriptPayoutSize)); InputsHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); bs.ReadWriteAsVarInt(ref PayloadSigSize); PayloadSig = data.ReadBytes((int)PayloadSigSize); MakeSureWeAreAtEndOfPayload(); }
public override void ReadWriteCore(BitcoinStream stream) { stream.ReadWrite(ref _BlockId); ulong indexes_size = (ulong)_Indices.Count; stream.ReadWriteAsVarInt(ref indexes_size); if(!stream.Serializing) { ulong i = 0; ulong indicesCount = 0; while((ulong)_Indices.Count < indexes_size) { indicesCount = Math.Min(1000UL + (ulong)indicesCount, (ulong)indexes_size); for(; i < indicesCount; i++) { ulong index = 0; stream.ReadWriteAsVarInt(ref index); if(index > Int32.MaxValue) throw new FormatException("indexes overflowed 31-bits"); _Indices.Add((int)index); } } int offset = 0; for(var ii = 0; ii < _Indices.Count; ii++) { if((ulong)(_Indices[ii]) + (ulong)(offset) > Int32.MaxValue) throw new FormatException("indexes overflowed 31-bits"); _Indices[ii] = _Indices[ii] + offset; offset = _Indices[ii] + 1; } } else { for(var i = 0; i < _Indices.Count; i++) { int index = _Indices[i] - (i == 0 ? 0 : (_Indices[i - 1] + 1)); stream.ReadWrite(ref index); } } }
public override void ReadWrite(BitcoinStream stream) { if (!stream.Serializing) { prevout = null; } stream.ReadWrite(ref prevout); stream.ReadWrite(ref scriptSig); stream.ReadWrite(ref nSequence); if (prevout.N == ANON_MARKER) { uint stack_size = stream.Serializing ? (uint)data.Length : 0; stream.ReadWriteAsVarInt(ref stack_size); if (!stream.Serializing) { data = new byte[stack_size][]; } for (int k = 0; k < stack_size; k++) { uint data_size = stream.Serializing ? (uint)data[k].Length : 0; stream.ReadWriteAsVarInt(ref data_size); byte[] data_stack = stream.Serializing ? data[k] : new byte[data_size]; if (data_size != 0) { stream.ReadWrite(ref data_stack); } if (!stream.Serializing) { data[k] = data_stack; } } } }
public ProviderUpdateServiceTransaction(byte[] extraPayload) : base(extraPayload) { ProTXHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); IpAddress = data.ReadBytes(IpAddressLength); Port = BitConverter.ToUInt16(data.ReadBytes(2).Reverse().ToArray(), 0); var bs = new BitcoinStream(data.BaseStream, false); bs.ReadWriteAsVarInt(ref ScriptOperatorPayoutSize); ScriptOperatorPayout = new Script(data.ReadBytes((int)ScriptOperatorPayoutSize)); InputsHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); PayloadSig = data.ReadBytes(BLS_SIGNATURE_SIZE); MakeSureWeAreAtEndOfPayload(); }
public ProviderUpdateRegistrarTransaction(byte[] extraPayload) : base(extraPayload) { ProTXHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); Mode = data.ReadUInt16(); PubKeyOperator = data.ReadBytes(BLS_PUBLIC_KEY_SIZE); KeyIdVoting = new uint160(data.ReadBytes(PUBKEY_ID_SIZE), true); var bs = new BitcoinStream(data.BaseStream, false); bs.ReadWriteAsVarInt(ref ScriptPayoutSize); ScriptPayout = new Script(data.ReadBytes((int)ScriptPayoutSize)); InputsHash = new uint256(data.ReadBytes(SHA256_HASH_SIZE), true); if (data.BaseStream.Position < data.BaseStream.Length) { bs.ReadWriteAsVarInt(ref PayloadSigSize); PayloadSig = data.ReadBytes((int)PayloadSigSize); } else { PayloadSig = new byte[0]; } MakeSureWeAreAtEndOfPayload(); }
public void ReadWrite(BitcoinStream stream) { stream.ReadWrite(ref _Outpoint); stream.ReadWrite(ref _Output); stream.ReadWriteAsVarInt(ref _Confirmations); uint[] indexes = _KeyPath?.Indexes ?? new uint[0]; stream.ReadWrite(ref indexes); if (!stream.Serializing) { _KeyPath = new KeyPath(indexes); } }
public override void ReadWrite(BitcoinStream stream) { base.ReadWrite(stream); // Support for Dash 0.13 extraPayload for Special Transactions // https://github.com/dashpay/dips/blob/master/dip-0002-special-transactions.md if (DashVersion >= 3 && DashType != DashTransactionType.StandardTransaction) { // Extra payload size is VarInt uint extraPayloadSize = (uint)ExtraPayload.Length; stream.ReadWriteAsVarInt(ref extraPayloadSize); if (ExtraPayload.Length != extraPayloadSize) { ExtraPayload = new byte[extraPayloadSize]; } stream.ReadWrite(ref ExtraPayload); } }
protected byte[] SerializeBlock(byte[] header, byte[] coinbase, byte[] solution) { var transactionCount = (uint) BlockTemplate.Transactions.Length + 1; var rawTransactionBuffer = BuildRawTransactionBuffer(); using(var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref header); bs.ReadWrite(ref solution); bs.ReadWriteAsVarInt(ref transactionCount); bs.ReadWrite(ref coinbase); bs.ReadWrite(ref rawTransactionBuffer); return stream.ToArray(); } }
private bool ReadData(byte[] data) { try { using (var ms = new MemoryStream(data)) { var stream = new BitcoinStream(ms, false); ushort marker = 0; stream.ReadWrite(ref marker); if (marker != Tag) { return(false); } stream.ReadWrite(ref this._Version); if (this._Version != 1) { return(false); } ulong quantityCount = 0; stream.ReadWriteAsVarInt(ref quantityCount); this.Quantities = new ulong[quantityCount]; for (ulong i = 0; i < quantityCount; i++) { this.Quantities[i] = ReadLEB128(stream); if (this.Quantities[i] > MAX_QUANTITY) { return(false); } } stream.ReadWriteAsVarString(ref this._Metadata); if (stream.Inner.Position != data.Length) { return(false); } return(true); } } catch (Exception) { return(false); } }
private byte[] SerializeBlock(Span <byte> header, Span <byte> coinbase, Span <byte> solution) { var transactionCount = (uint)BlockTemplate.Transactions.Length + 1; // +1 for prepended coinbase tx var rawTransactionBuffer = BuildRawTransactionBuffer(); using (var stream = new MemoryStream()) { var bs = new BitcoinStream(stream, true); bs.ReadWrite(ref header); bs.ReadWrite(ref solution); bs.ReadWriteAsVarInt(ref transactionCount); bs.ReadWrite(ref coinbase); bs.ReadWrite(ref rawTransactionBuffer); return(stream.ToArray()); } }
private bool ReadScript(Script script) { var data = TxNullDataTemplate.Instance.ExtractScriptPubKeyParameters(script); if (data == null) { return(false); } BitcoinStream stream = new BitcoinStream(data); ushort marker = 0; stream.ReadWrite(ref marker); if (marker != Tag) { return(false); } stream.ReadWrite(ref _Version); if (_Version != 1) { return(false); } ulong quantityCount = 0; stream.ReadWriteAsVarInt(ref quantityCount); Quantities = new ulong[quantityCount]; try { for (ulong i = 0; i < quantityCount; i++) { Quantities[i] = ReadLEB128(stream); if (Quantities[i] > MAX_QUANTITY) { throw new FormatException(); } } } catch (FormatException) { return(false); } stream.ReadWriteAsVarString(ref _Metadata); return(true); }
public void ReadWrite(BitcoinStream stream) { stream.ReadWriteAsVarInt(ref _Index); if (stream.Serializing) { byte[] assetId = Asset.Id.ToBytes(); stream.ReadWrite(ref assetId); long quantity = Asset.Quantity; stream.ReadWrite(ref quantity); } else { byte[] assetId = new byte[20]; stream.ReadWrite(ref assetId); long quantity = 0; stream.ReadWrite(ref quantity); Asset = new AssetMoney(new AssetId(assetId), quantity); } }
public void ReadWrite(BitcoinStream stream) { stream.ReadWriteAsVarInt(ref _Index); if(stream.Serializing) { byte[] assetId = Asset.Id.ToBytes(); stream.ReadWrite(ref assetId); long quantity = Asset.Quantity; stream.ReadWrite(ref quantity); } else { byte[] assetId = new byte[20]; stream.ReadWrite(ref assetId); long quantity = 0; stream.ReadWrite(ref quantity); Asset = new AssetMoney(new AssetId(assetId), quantity); } }
public byte[] ToBytes() { MemoryStream ms = new MemoryStream(); BitcoinStream stream = new BitcoinStream(ms, true); stream.ReadWrite(Tag); stream.ReadWrite(ref _Version); var quantityCount = (uint)this.Quantities.Length; stream.ReadWriteAsVarInt(ref quantityCount); for (int i = 0; i < quantityCount; i++) { if (Quantities[i] > MAX_QUANTITY) { throw new ArgumentOutOfRangeException("Quantity should not exceed " + Quantities[i]); } WriteLEB128(Quantities[i], stream); } stream.ReadWriteAsVarString(ref _Metadata); return(ms.ToArray()); }
public override void ReadWrite(BitcoinStream stream) { var isNewFormat = !stream.Serializing || (nSolutionSize != 0); stream.ReadWrite(ref nVersion); stream.ReadWrite(ref hashPrevBlock); stream.ReadWrite(ref hashMerkleRoot); stream.ReadWrite(ref hashReserved); stream.ReadWrite(ref nTime); stream.ReadWrite(ref nBits); stream.ReadWrite(ref nNonce); if (nSolutionSize > 0) { stream.ReadWriteAsVarInt(ref nSolutionSize); if (!stream.Serializing) { nSolution = new byte[nSolutionSize]; } stream.ReadWrite(ref nSolution); } }
public override void ReadWrite(BitcoinStream stream) { var isNewFormat = !stream.Serializing || (nSolutionSize != 0); stream.ReadWrite(ref nVersion); stream.ReadWrite(ref hashPrevBlock); stream.ReadWrite(ref hashMerkleRoot); if (isNewFormat) { stream.ReadWrite(ref nHeight); for (int i = 0; i < vReserved.Length; i++) { uint nReserved = 0; stream.ReadWrite(ref nReserved); vReserved[i] = nReserved; } } stream.ReadWrite(ref nTime); stream.ReadWrite(ref nBits); if (isNewFormat) { stream.ReadWrite(ref nNewNonce); stream.ReadWriteAsVarInt(ref nSolutionSize); if (nSolutionSize > 0) { if (!stream.Serializing) { nSolution = new byte[nSolutionSize]; } stream.ReadWrite(ref nSolution); } } else { nNonce = nNewNonce.GetLow32(); stream.ReadWrite(ref nNonce); nNewNonce = new uint256(nNonce); } }
public byte[] ToBytes() { MemoryStream ms = new MemoryStream(); BitcoinStream stream = new BitcoinStream(ms, true); stream.ReadWrite(Tag); stream.ReadWrite(ref _Version); var quantityCount = (uint)this.Quantities.Length; stream.ReadWriteAsVarInt(ref quantityCount); for(int i = 0 ; i < quantityCount ; i++) { if(Quantities[i] > MAX_QUANTITY) throw new ArgumentOutOfRangeException("Quantity should not exceed " + Quantities[i]); WriteLEB128(Quantities[i], stream); } stream.ReadWriteAsVarString(ref _Metadata); return ms.ToArray(); }
public override void ReadWriteCore(BitcoinStream stream) { stream.ReadWrite(ref _Header); stream.ReadWrite(ref _Nonce); var shorttxids_size = (uint)_ShortIds.Count; stream.ReadWriteAsVarInt(ref shorttxids_size); if(!stream.Serializing) { ulong i = 0; ulong shottxidsCount = 0; while(_ShortIds.Count < shorttxids_size) { shottxidsCount = Math.Min(1000UL + (ulong)shottxidsCount, (ulong)shorttxids_size); for(; i < shottxidsCount; i++) { uint lsb = 0; ushort msb = 0; stream.ReadWrite(ref lsb); stream.ReadWrite(ref msb); _ShortIds.Add(((ulong)(msb) << 32) | (ulong)(lsb)); } } } else { for(var i = 0; i < _ShortIds.Count; i++) { uint lsb = (uint)(_ShortIds[i] & 0xffffffff); ushort msb = (ushort)((_ShortIds[i] >> 32) & 0xffff); stream.ReadWrite(ref lsb); stream.ReadWrite(ref msb); } } ulong txn_size = (ulong)PrefilledTransactions.Count; stream.ReadWriteAsVarInt(ref txn_size); if(!stream.Serializing) { ulong i = 0; ulong indicesCount = 0; while((ulong)PrefilledTransactions.Count < txn_size) { indicesCount = Math.Min(1000UL + (ulong)indicesCount, (ulong)txn_size); for(; i < indicesCount; i++) { ulong index = 0; stream.ReadWriteAsVarInt(ref index); if(index > Int32.MaxValue) throw new FormatException("indexes overflowed 32-bits"); Transaction tx = null; stream.ReadWrite(ref tx); PrefilledTransactions.Add(new PrefilledTransaction() { Index = (int)index, Transaction = tx }); } } int offset = 0; for(var ii = 0; ii < PrefilledTransactions.Count; ii++) { if((ulong)(PrefilledTransactions[ii].Index) + (ulong)(offset) > Int32.MaxValue) throw new FormatException("indexes overflowed 31-bits"); PrefilledTransactions[ii].Index = PrefilledTransactions[ii].Index + offset; offset = PrefilledTransactions[ii].Index + 1; } } else { for(var i = 0; i < PrefilledTransactions.Count; i++) { uint index = checked((uint)(PrefilledTransactions[i].Index - (i == 0 ? 0 : (PrefilledTransactions[i - 1].Index + 1)))); stream.ReadWriteAsVarInt(ref index); Transaction tx = PrefilledTransactions[i].Transaction; stream.ReadWrite(ref tx); } } if(!stream.Serializing) UpdateShortTxIDSelector(); }
public Script GetScript() { MemoryStream ms = new MemoryStream(); BitcoinStream stream = new BitcoinStream(ms, true); stream.ReadWrite(Tag); stream.ReadWrite(ref _Version); var quantityCount = (uint)this.Quantities.Length; stream.ReadWriteAsVarInt(ref quantityCount); for(int i = 0 ; i < quantityCount ; i++) { if(Quantities[i] > MAX_QUANTITY) throw new ArgumentOutOfRangeException("Quantity should not exceed " + Quantities[i]); WriteLEB128(Quantities[i], stream); } stream.ReadWriteAsVarString(ref _Metadata); return TxNullDataTemplate.Instance.GenerateScriptPubKey(ms.ToArray()); }
public void ReadWrite(BitcoinStream stream) { if(stream.Serializing) { uint nMaskSize = 0, nMaskCode = 0; CalcMaskSize(ref nMaskSize, ref nMaskCode); bool fFirst = vout.Count > 0 && !vout[0].IsNull; bool fSecond = vout.Count > 1 && !vout[1].IsNull; uint nCode = unchecked((uint)(8 * (nMaskCode - (fFirst || fSecond ? 0 : 1)) + (fCoinBase ? 1 : 0) + (fFirst ? 2 : 0) + (fSecond ? 4 : 0))); // version stream.ReadWriteAsVarInt(ref nVersion); // size of header code stream.ReadWriteAsVarInt(ref nCode); // spentness bitmask for(uint b = 0 ; b < nMaskSize ; b++) { byte chAvail = 0; for(uint i = 0 ; i < 8 && 2 + b * 8 + i < vout.Count ; i++) if(!vout[2 + (int)b * 8 + (int)i].IsNull) chAvail |= (byte)(1 << (int)i); stream.ReadWrite(ref chAvail); } // txouts themself for(uint i = 0 ; i < vout.Count ; i++) { if(!vout[(int)i].IsNull) { var compressedTx = new TxOutCompressor(vout[(int)i]); stream.ReadWrite(ref compressedTx); } } // coinbase height stream.ReadWriteAsVarInt(ref nHeight); } else { uint nCode = 0; // version stream.ReadWriteAsVarInt(ref nVersion); //// header code stream.ReadWriteAsVarInt(ref nCode); fCoinBase = (nCode & 1) != 0; List<bool> vAvail = new List<bool>() { false, false }; vAvail[0] = (nCode & 2) != 0; vAvail[1] = (nCode & 4) != 0; uint nMaskCode = unchecked((uint)((nCode / 8) + ((nCode & 6) != 0 ? 0 : 1))); //// spentness bitmask while(nMaskCode > 0) { byte chAvail = 0; stream.ReadWrite(ref chAvail); for(uint p = 0 ; p < 8 ; p++) { bool f = (chAvail & (1 << (int)p)) != 0; vAvail.Add(f); } if(chAvail != 0) nMaskCode--; } // txouts themself vout = Enumerable.Range(0, vAvail.Count).Select(_ => new TxOut()).ToList(); for(uint i = 0 ; i < vAvail.Count ; i++) { if(vAvail[(int)i]) { TxOutCompressor compressed = new TxOutCompressor(); stream.ReadWrite(ref compressed); vout[(int)i] = compressed.TxOut; } } //// coinbase height stream.ReadWriteAsVarInt(ref nHeight); Cleanup(); UpdateValue(); } }