internal static Secp256k1.SecpECDSASignature Sign(this Secp256k1.ECPrivKey key, uint256 h, bool enforceLowR, out int recid) { Span <byte> hash = stackalloc byte[32]; h.ToBytes(hash); byte[] extra_entropy = null; Secp256k1.RFC6979NonceFunction nonceFunction = null; Span <byte> vchSig = stackalloc byte[Secp256k1.SecpECDSASignature.MaxLength]; Secp256k1.SecpECDSASignature sig; uint counter = 0; bool ret = key.TrySignECDSA(hash, null, out recid, out sig); // Grind for low R while (ret && sig.r.IsHigh && enforceLowR) { if (extra_entropy == null || nonceFunction == null) { extra_entropy = new byte[32]; nonceFunction = new Secp256k1.RFC6979NonceFunction(extra_entropy); } Utils.ToBytes(++counter, true, extra_entropy.AsSpan()); ret = key.TrySignECDSA(hash, nonceFunction, out recid, out sig); } return(sig); }
public byte[] ToBytes(bool lendian = true) { var arr = new byte[WIDTH_BYTE]; Buffer.BlockCopy(Utils.ToBytes(pn0, true), 0, arr, 4 * 0, 4); Buffer.BlockCopy(Utils.ToBytes(pn1, true), 0, arr, 4 * 1, 4); Buffer.BlockCopy(Utils.ToBytes(pn2, true), 0, arr, 4 * 2, 4); Buffer.BlockCopy(Utils.ToBytes(pn3, true), 0, arr, 4 * 3, 4); Buffer.BlockCopy(Utils.ToBytes(pn4, true), 0, arr, 4 * 4, 4); Buffer.BlockCopy(Utils.ToBytes(pn5, true), 0, arr, 4 * 5, 4); Buffer.BlockCopy(Utils.ToBytes(pn6, true), 0, arr, 4 * 6, 4); Buffer.BlockCopy(Utils.ToBytes(pn7, true), 0, arr, 4 * 7, 4); Buffer.BlockCopy(Utils.ToBytes(pn8, true), 0, arr, 4 * 8, 4); Buffer.BlockCopy(Utils.ToBytes(pn9, true), 0, arr, 4 * 9, 4); Buffer.BlockCopy(Utils.ToBytes(pn10, true), 0, arr, 4 * 10, 4); Buffer.BlockCopy(Utils.ToBytes(pn11, true), 0, arr, 4 * 11, 4); Buffer.BlockCopy(Utils.ToBytes(pn12, true), 0, arr, 4 * 12, 4); Buffer.BlockCopy(Utils.ToBytes(pn13, true), 0, arr, 4 * 13, 4); Buffer.BlockCopy(Utils.ToBytes(pn14, true), 0, arr, 4 * 14, 4); Buffer.BlockCopy(Utils.ToBytes(pn15, true), 0, arr, 4 * 15, 4); if (!lendian) { Array.Reverse(arr); } return(arr); }
public void ToBytes(Span <byte> output, bool lendian = true) { if (output.Length < WIDTH_BYTE) { throw new ArgumentException(message: $"The array should be at least of size {WIDTH_BYTE}", paramName: nameof(output)); } var initial = output; Utils.ToBytes(pn0, true, output); output = output.Slice(4); Utils.ToBytes(pn1, true, output); output = output.Slice(4); Utils.ToBytes(pn2, true, output); output = output.Slice(4); Utils.ToBytes(pn3, true, output); output = output.Slice(4); Utils.ToBytes(pn4, true, output); output = output.Slice(4); Utils.ToBytes(pn5, true, output); output = output.Slice(4); Utils.ToBytes(pn6, true, output); output = output.Slice(4); Utils.ToBytes(pn7, true, output); if (!lendian) { initial.Reverse(); } }
public void ToBytes(byte[] output) { Buffer.BlockCopy(Utils.ToBytes(pn0, true), 0, output, 4 * 0, 4); Buffer.BlockCopy(Utils.ToBytes(pn1, true), 0, output, 4 * 1, 4); Buffer.BlockCopy(Utils.ToBytes(pn2, true), 0, output, 4 * 2, 4); Buffer.BlockCopy(Utils.ToBytes(pn3, true), 0, output, 4 * 3, 4); Buffer.BlockCopy(Utils.ToBytes(pn4, true), 0, output, 4 * 4, 4); Buffer.BlockCopy(Utils.ToBytes(pn5, true), 0, output, 4 * 5, 4); Buffer.BlockCopy(Utils.ToBytes(pn6, true), 0, output, 4 * 6, 4); Buffer.BlockCopy(Utils.ToBytes(pn7, true), 0, output, 4 * 7, 4); }
public StealthMetadata(Key ephemKey, uint nonce) { var data = new MemoryStream(); data.WriteByte(6); var b = Utils.ToBytes(nonce, true); data.Write(b, 0, b.Length); data.Write(ephemKey.PubKey.Compress().ToBytes(), 0, 33); Fill(this, new Script(OpcodeType.OP_RETURN, Op.GetPushOp(data.ToArray()))); }
public byte[] ToBytes(bool lendian = true) { var arr = new byte[WIDTH_BYTE]; for (int i = 0; i < WIDTH; i++) { Buffer.BlockCopy(Utils.ToBytes(pn[i], true), 0, arr, 4 * i, 4); } if (!lendian) { Array.Reverse(arr); } return(arr); }
public byte[] ToBytes(bool lendian = true) { var arr = new byte[WIDTH_BYTE]; Buffer.BlockCopy(Utils.ToBytes(pn0, true), 0, arr, 4 * 0, 4); Buffer.BlockCopy(Utils.ToBytes(pn1, true), 0, arr, 4 * 1, 4); Buffer.BlockCopy(Utils.ToBytes(pn2, true), 0, arr, 4 * 2, 4); Buffer.BlockCopy(Utils.ToBytes(pn3, true), 0, arr, 4 * 3, 4); Buffer.BlockCopy(Utils.ToBytes(pn4, true), 0, arr, 4 * 4, 4); if (!lendian) { Array.Reverse(arr); } return(arr); }
public byte[] ToBytes() { var b = new byte[Length]; int i = 0; b[i++] = nDepth; Array.Copy(parentFingerprint.ToBytes(), 0, b, i, 4); i += 4; Array.Copy(Utils.ToBytes(nChild, false), 0, b, i, 4); i += 4; Array.Copy(vchChainCode, 0, b, i, 32); i += 32; Array.Copy(pubkey.ToBytes(), 0, b, i, 33); return(b); }
public void ToBytes(Span <byte> output, bool lendian = true) { if (output.Length < WIDTH_BYTE) { throw new ArgumentException(message: $"The array should be at least of size {WIDTH_BYTE}", paramName: nameof(output)); } if (BitConverter.IsLittleEndian) { if (lendian) { var ulongOutput = MemoryMarshal.Cast <byte, ulong>(output); ulongOutput[0] = pn0; ulongOutput[1] = pn1; ulongOutput[2] = pn2; ulongOutput[3] = pn3; } else { Span <ulong> temp = stackalloc ulong[4]; temp[0] = pn0; temp[1] = pn1; temp[2] = pn2; temp[3] = pn3; var tempBytes = MemoryMarshal.Cast <ulong, byte>(temp); tempBytes.Reverse(); tempBytes.CopyTo(output); } return; } var initial = output; Utils.ToBytes(pn0, true, output); output = output.Slice(8); Utils.ToBytes(pn1, true, output); output = output.Slice(8); Utils.ToBytes(pn2, true, output); output = output.Slice(8); Utils.ToBytes(pn3, true, output); if (!lendian) { initial.Reverse(); } }
public bool Match(uint value) { var data = Utils.ToBytes(value, true); if (data.Length * 8 < _BitCount) { return(false); } for (int i = 0; i < _Mask.Length; i++) { if ((data[i] & _Mask[i]) != (_Rawform[i] & _Mask[i])) { return(false); } } return(true); }
/// <summary> /// Write this instance to the output /// </summary> /// <param name="output"></param> /// <param name="lendian"></param> public void ToBytes(byte[] output, bool lendian) { #if HAS_SPAN ToBytes(output.AsSpan(), lendian); #else if (lendian) { Buffer.BlockCopy(Utils.ToBytes(pn0, true), 0, output, 8 * 0, 8); Buffer.BlockCopy(Utils.ToBytes(pn1, true), 0, output, 8 * 1, 8); Buffer.BlockCopy(Utils.ToBytes(pn2, true), 0, output, 8 * 2, 8); Buffer.BlockCopy(Utils.ToBytes(pn3, true), 0, output, 8 * 3, 8); } else { Buffer.BlockCopy(Utils.ToBytes(pn3, false), 0, output, 8 * 0, 8); Buffer.BlockCopy(Utils.ToBytes(pn2, false), 0, output, 8 * 1, 8); Buffer.BlockCopy(Utils.ToBytes(pn1, false), 0, output, 8 * 2, 8); Buffer.BlockCopy(Utils.ToBytes(pn0, false), 0, output, 8 * 3, 8); } #endif }
private static BitArray CalculateChecksum(uint256 blockId, int txIndex, int txOutIndex, Script scriptPubKey, int bitCount) { //All in little endian var hashed = blockId .ToBytes(true) .Concat(Utils.ToBytes((uint)txIndex, true)) .Concat(Utils.ToBytes((uint)txOutIndex, true)) .Concat(scriptPubKey.ToBytes(true)) .ToArray(); var hash = Hashes.Hash256(hashed); var bytes = hash.ToBytes(true); BitArray result = new BitArray(bitCount); for (int i = 0; i < bitCount; i++) { int byteIndex = i / 8; int bitIndex = i % 8; result.Set(i, ((bytes[byteIndex] >> bitIndex) & 1) == 1); } return(result); }
public void ToBytes(Span <byte> output) { Utils.ToBytes(_Value, true, output); }
public DerivationStrategyBase Parse(string str) { if (str == null) { throw new ArgumentNullException(nameof(str)); } str = str.Trim(); HashSet <string> hintedLabels = new HashSet <string>(); var hintDestination = HintScriptPubKey?.GetDestination(); if (hintDestination != null) { if (hintDestination is KeyId) { hintedLabels.Add("legacy"); } if (hintDestination is ScriptId) { hintedLabels.Add("p2sh"); } } else { if (Network.Consensus.SupportSegwit) { hintedLabels.Add("p2sh"); } else { hintedLabels.Add("legacy"); } } try { var result = new DerivationStrategyFactory(Network).Parse(str); return(FindMatch(hintedLabels, result)); } catch { } Dictionary <uint, string[]> electrumMapping = new Dictionary <uint, string[]>(); //Source https://github.com/spesmilo/electrum/blob/9edffd17542de5773e7284a8c8a2673c766bb3c3/lib/bitcoin.py var standard = 0x0488b21eU; electrumMapping.Add(standard, new[] { "legacy" }); var p2wpkh_p2sh = 0x049d7cb2U; electrumMapping.Add(p2wpkh_p2sh, new string[] { "p2sh" }); var p2wpkh = 0x4b24746U; electrumMapping.Add(p2wpkh, Array.Empty <string>()); var parts = str.Split('-'); for (int i = 0; i < parts.Length; i++) { if (IsLabel(parts[i])) { hintedLabels.Add(parts[i].Substring(1, parts[i].Length - 2).ToLowerInvariant()); continue; } try { var data = Network.GetBase58CheckEncoder().DecodeData(parts[i]); if (data.Length < 4) { continue; } var prefix = NU.ToUInt32(data, false); var standardPrefix = NU.ToBytes(Network.NetworkType == NetworkType.Mainnet ? 0x0488b21eU : 0x043587cf, false); for (int ii = 0; ii < 4; ii++) { data[ii] = standardPrefix[ii]; } var derivationScheme = new BitcoinExtPubKey(Network.GetBase58CheckEncoder().EncodeData(data), Network).ToString(); electrumMapping.TryGetValue(prefix, out string[] labels); if (labels != null) { foreach (var label in labels) { hintedLabels.Add(label.ToLowerInvariant()); } } parts[i] = derivationScheme; } catch { continue; } } if (hintDestination != null) { if (hintDestination is WitKeyId) { hintedLabels.Remove("legacy"); hintedLabels.Remove("p2sh"); } } str = string.Join('-', parts.Where(p => !IsLabel(p))); foreach (var label in hintedLabels) { str = $"{str}-[{label}]"; } return(FindMatch(hintedLabels, new DerivationStrategyFactory(Network).Parse(str))); }
public BitField(uint encodedForm, int bitcount) : this(Utils.ToBytes(encodedForm, true), bitcount) { }
public byte[] ToBytes() => Indexes.Count() == 0 ? new byte[0] : Indexes.Select(i => Utils.ToBytes(i, true)).Aggregate((a, b) => a.Concat(b)).ToArray();
public void Serialize(BitcoinStream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } // Write the utxo // If there is a non-witness utxo, then don't serialize the witness one. if (witness_utxo != null) { // key stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_WITNESS_UTXO; stream.ReadWrite(ref key); // value var data = witness_utxo.ToBytes(); stream.ReadWriteAsVarString(ref data); } if (non_witness_utxo != null) { // key stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_NON_WITNESS_UTXO; stream.ReadWrite(ref key); // value byte[] data = non_witness_utxo.ToBytes(); stream.ReadWriteAsVarString(ref data); } // Write the sighash type if (sighash_type > 0) { stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_SIGHASH; stream.ReadWrite(ref key); var tmp = Utils.ToBytes((uint)sighash_type, true); stream.ReadWriteAsVarString(ref tmp); } // Write the redeem script if (redeem_script != null) { stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_REDEEMSCRIPT; stream.ReadWrite(ref key); var value = redeem_script.ToBytes(); stream.ReadWriteAsVarString(ref value); } // Write the witness script if (witness_script != null) { stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_WITNESSSCRIPT; stream.ReadWrite(ref key); var value = witness_script.ToBytes(); stream.ReadWriteAsVarString(ref value); } // Write any partial signatures foreach (var sig_pair in partial_sigs) { var key = new byte[] { PSBTConstants.PSBT_IN_PARTIAL_SIG }.Concat(sig_pair.Key.ToBytes()); stream.ReadWriteAsVarString(ref key); var sig = sig_pair.Value.ToBytes(); stream.ReadWriteAsVarString(ref sig); } // Write any hd keypaths foreach (var pathPair in hd_keypaths) { var key = new byte[] { PSBTConstants.PSBT_IN_BIP32_DERIVATION }.Concat(pathPair.Key.ToBytes()); stream.ReadWriteAsVarString(ref key); var masterFingerPrint = pathPair.Value.MasterFingerprint; var path = pathPair.Value.KeyPath.ToBytes(); var pathInfo = masterFingerPrint.ToBytes().Concat(path); stream.ReadWriteAsVarString(ref pathInfo); } // Write script sig if (final_script_sig != null) { stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_SCRIPTSIG; stream.ReadWrite(ref key); byte[] value = final_script_sig.ToBytes(); stream.ReadWriteAsVarString(ref value); } // write script witness if (final_script_witness != null) { stream.ReadWriteAsVarInt(ref defaultKeyLen); var key = PSBTConstants.PSBT_IN_SCRIPTWITNESS; stream.ReadWrite(ref key); var stack = final_script_witness.ToBytes(); stream.ReadWriteAsVarString(ref stack); } // Write unknown things foreach (var entry in unknown) { var k = entry.Key; var v = entry.Value; stream.ReadWriteAsVarString(ref k); stream.ReadWriteAsVarString(ref v); } var sep = PSBTConstants.PSBT_SEPARATOR; stream.ReadWrite(ref sep); }
public byte[] ToBytes() { return(Utils.ToBytes(_Value, true)); }