public static bool TryFromScript(byte[] script, out PubKey pubKey)
{
if (script == null)
throw new ArgumentNullException(nameof(script));
throw new NotImplementedException();
}
public FullBlockTestGenerator(Network network)
{
_Network = network;
coinbaseOutKey = new Key();
coinbaseOutKeyPubKey = coinbaseOutKey.PubKey;
//Utils.rollMockClock(0); // Set a mock clock for timestamp tests
}
public static Script CreatePaymentScript(int sigCount, PubKey[] uncoveredPubKeys)
{
if(sigCount == 1 && uncoveredPubKeys.Length == 1)
{
return PayToPubkeyHashTemplate.Instance.GenerateScriptPubKey(uncoveredPubKeys[0].Hash);
}
else
{
return PayToMultiSigTemplate.Instance.GenerateScriptPubKey(sigCount, uncoveredPubKeys);
}
}
public void CanUseSegwitAddress()
{
var address = (BitcoinWitPubKeyAddress)BitcoinAddress.Create("p2xtZoXeX5X8BP8JfFhQK2nD3emtjch7UeFm");
Assert.Equal("0014010966776006953d5567439e5e39f86a0d273bee", address.ScriptPubKey.ToHex());
Assert.Equal("0014010966776006953d5567439e5e39f86a0d273bee", address.Hash.ScriptPubKey.ToHex());
Assert.Equal("3R1ZpeYRXx5oFtJWNoUwLFoACixRQ7sDQa", address.GetScriptAddress().ToString());
//Example of the BIP
var pubkey = new PubKey("0450863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B23522CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6");
Assert.Equal(new Script("OP_0 010966776006953D5567439E5E39F86A0D273BEE"), pubkey.GetSegwitAddress(Network.Main).ScriptPubKey);
Assert.Equal("p2xtZoXeX5X8BP8JfFhQK2nD3emtjch7UeFm", pubkey.GetSegwitAddress(Network.Main).ToString());
}
private static Gen <TxOut> OutputFromRedeemOrKey(Script sc, PubKey key) => sc != null?OutputFromRedeem(sc) : OutputFromKey(key);
public static void PubKeyNotCompressed(string argumentName, PubKey pk) =>
throw new InvalidDataException($"invalid {argumentName}: public key must be compressed. {pk.ToHex()}");
public static Transaction SetupValidTransaction(Features.Wallet.Wallet wallet, string password, HdAddress spendingAddress, PubKey destinationPubKey, HdAddress changeAddress, Money amount, Money fee)
{
var spendingTransaction = spendingAddress.Transactions.ElementAt(0);
Coin coin = new Coin(spendingTransaction.Id, (uint)spendingTransaction.Index, spendingTransaction.Amount, spendingTransaction.ScriptPubKey);
var privateKey = Key.Parse(wallet.EncryptedSeed, password, wallet.Network);
var builder = new TransactionBuilder(wallet.Network);
Transaction tx = builder
.AddCoins(new List <Coin> {
coin
})
.AddKeys(new ExtKey(privateKey, wallet.ChainCode).Derive(new KeyPath(spendingAddress.HdPath)).GetWif(wallet.Network))
.Send(destinationPubKey.ScriptPubKey, amount)
.SetChange(changeAddress.ScriptPubKey)
.SendFees(fee)
.BuildTransaction(true);
if (!builder.Verify(tx))
{
throw new WalletException("Could not build transaction, please make sure you entered the correct data.");
}
return(tx);
}
public BitcoinWitPubKeyAddress GetP2wpkhAddress(Network network) => PubKey.GetSegwitAddress(network);
internal void AddKeyPubKey(Key key, PubKey pubkey)
{
_Keys.Add(Tuple.Create(key, pubkey));
}
private static byte[] GenerateBytes(PubKey scanKey, PubKey[] pubKeys, BitField bitField, int signatureCount)
{
MemoryStream ms = new MemoryStream();
ms.WriteByte(0); //Options
ms.Write(scanKey.Compress().ToBytes(), 0, 33);
ms.WriteByte((byte)pubKeys.Length);
foreach(var key in pubKeys)
{
ms.Write(key.Compress().ToBytes(), 0, 33);
}
ms.WriteByte((byte)signatureCount);
if(bitField == null)
ms.Write(new byte[] { 0 }, 0, 1);
else
{
ms.WriteByte((byte)bitField.BitCount);
var raw = bitField.GetRawForm();
ms.Write(raw, 0, raw.Length);
}
return ms.ToArray();
}
public SignedContractsPoARegTest()
{
this.Name = "SignedContractsPoARegTest";
this.SigningContractPrivKey = new Mnemonic("lava frown leave wedding virtual ghost sibling able mammal liar wide wisdom").DeriveExtKey().PrivateKey;
this.SigningContractPubKey = this.SigningContractPrivKey.PubKey;
}
public bool VerifySignature(string url, PubKey key)
{
uint256 hash = new uint256(Hashes.SHA256(Encoding.UTF8.GetBytes(GetMessage(url))));
return(key.Verify(hash, new ECDSASignature(Encoders.Hex.DecodeData(Signature))));
}
public EscrowScriptPubKeyParameters(PubKey initiator, PubKey receiver, LockTime lockTime)
{
this.Initiator = initiator;
this.Receiver = receiver;
this.LockTime = lockTime;
}
private TxOut BuildToRemoteOutput(ulong toRemote)
{
PubKey pubKey = new PubKey(RemotePaymentPubKey.PublicKeyCompressed);
return(new TxOut(Money.Satoshis(toRemote), pubKey.WitHash.ScriptPubKey));
}
public static bool Match(BitcoinExtPubKey bitcoinExtPubKey, int change, int i, FilterModel[] filterArray, out PubKey pubKey)
{
KeyPath path = new KeyPath($"{change}/{i}");
pubKey = bitcoinExtPubKey.ExtPubKey.Derive(path).PubKey;
byte[] bytes = pubKey.WitHash.ScriptPubKey.ToCompressedBytes();
foreach (var filterModel in filterArray)
{
bool?matchFoundNow = filterModel.Filter?.Match(bytes, filterModel.FilterKey);
if (matchFoundNow is true)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Checks if block signature is valid.
/// </summary>
/// <param name="block">The block.</param>
/// <returns><c>true</c> if the signature is valid, <c>false</c> otherwise.</returns>
private bool CheckBlockSignature(Block block)
{
this.Logger.LogTrace("()");
if (BlockStake.IsProofOfWork(block))
{
bool res = block.BlockSignatur.IsEmpty();
this.Logger.LogTrace("(-)[POW]:{0}", res);
return(res);
}
if (block.BlockSignatur.IsEmpty())
{
this.Logger.LogTrace("(-)[EMPTY]:false");
return(false);
}
TxOut txout = block.Transactions[1].Outputs[1];
if (PayToPubkeyTemplate.Instance.CheckScriptPubKey(txout.ScriptPubKey))
{
PubKey pubKey = PayToPubkeyTemplate.Instance.ExtractScriptPubKeyParameters(txout.ScriptPubKey);
bool res = pubKey.Verify(block.GetHash(), new ECDSASignature(block.BlockSignatur.Signature));
this.Logger.LogTrace("(-)[P2PK]:{0}", res);
return(res);
}
// Block signing key also can be encoded in the nonspendable output.
// This allows to not pollute UTXO set with useless outputs e.g. in case of multisig staking.
List <Op> ops = txout.ScriptPubKey.ToOps().ToList();
if (!ops.Any()) // script.GetOp(pc, opcode, vchPushValue))
{
this.Logger.LogTrace("(-)[NO_OPS]:false");
return(false);
}
if (ops.ElementAt(0).Code != OpcodeType.OP_RETURN) // OP_RETURN)
{
this.Logger.LogTrace("(-)[NO_OP_RETURN]:false");
return(false);
}
if (ops.Count < 2) // script.GetOp(pc, opcode, vchPushValue)
{
this.Logger.LogTrace("(-)[NO_SECOND_OP]:false");
return(false);
}
byte[] data = ops.ElementAt(1).PushData;
if (!ScriptEvaluationContext.IsCompressedOrUncompressedPubKey(data))
{
this.Logger.LogTrace("(-)[NO_PUSH_DATA]:false");
return(false);
}
bool verifyRes = new PubKey(data).Verify(block.GetHash(this.Parent.ConsensusParams.NetworkOptions), new ECDSASignature(block.BlockSignatur.Signature));
this.Logger.LogTrace("(-):{0}", verifyRes);
return(verifyRes);
}
private void Peer_NewMessage(object sender, Message message)
{
if (ProcessedMessages.Contains(message))
{
return;
}
ProcessedMessages.Add(message);
Console.Write($"{Name} received message: ");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(message);
Console.ResetColor();
NewMessage?.Invoke(this, message);
if (message.Type == MessageType.PublicKey)
{
var pubKey = new PubKey(message.GetDataString());
AllPubKeys.Add(pubKey);
if (AllPubKeys.Count == RequiredPeerCount)
{
// every participant (say participant i in a predefined shuffling
// order) uses the encryption keys of every participant j > i to create a layered
// encryption of her output address.
string onion = OnionEncrypt(AllPubKeys, OutputScript.ToString());
Broadcast(new Message(MessageType.Onions, onion));
}
}
else if (message.Type == MessageType.Onions)
{
var onions = message.GetDataCollection();
if (onions.Count() == 1)
{
Onions.Add(onions.Single());
if (Onions.Count == RequiredPeerCount)
{
if (SecretKey.CanDecrypt(Onions.First()))
{
var stripped = Decrypt(SecretKey, Onions).ToList();
stripped.Shuffle();
Broadcast(new Message(MessageType.Onions, stripped));
}
}
}
else if (SecretKey.CanDecrypt(onions.First()))
{
var stripped = Decrypt(SecretKey, onions).ToList();
stripped.Shuffle();
if (NBitcoinHelpers.IsScript(stripped.First()))
{
Broadcast(new Message(MessageType.ShuffledScripts, stripped));
}
else
{
Broadcast(new Message(MessageType.Onions, stripped));
}
}
}
}
public void CanVerifyTrezorSignature()
{
string visual_challenge = "2015-03-23 17:39:22";
byte[] random_challenge = Encoders.Hex.DecodeData("cd8552569d6e4509266ef137584d1e62c7579b5b8ed69bbafa4b864c6521e7c2");
byte[] signature = Encoders.Hex.DecodeData("20f2d1a42d08c3a362be49275c3ffeeaa415fc040971985548b9f910812237bb41770bf2c8d488428799fbb7e52c11f1a3404011375e4080e077e0e42ab7a5ba02");
var hiddenChallenge_Sha = Hashes.SHA256(random_challenge);
var visualChallenge_Sha = Hashes.SHA256(Encoding.ASCII.GetBytes(visual_challenge));
PubKey pubKey = new PubKey("023a472219ad3327b07c18273717bb3a40b39b743756bf287fbd5fa9d263237f45");
bool verified = pubKey.VerifyMessage(hiddenChallenge_Sha.Concat(visualChallenge_Sha).ToArray(), Encoders.Base64.EncodeData(signature));
Assert.True(verified);
}
public BitcoinBlindedAddress(PubKey blindingKey, BitcoinAddress address)
: base(GetBase58(blindingKey, address), address.Network)
{
_BlindingKey = blindingKey;
_UnblindedAddress = address;
}
public SchnorrPubKey(PubKey signerPubKey, PubKey rPubKey)
{
SignerPubKey = Guard.NotNull(nameof(signerPubKey), signerPubKey);
RpubKey = Guard.NotNull(nameof(rPubKey), rPubKey);
}
/// <summary>
/// Try to interpret the given string in a few ways in order to detect what object it's supposed to represent.
/// </summary>
/// <returns>The object represented by the input string. This may be a Bitcoin address, a script, a signature, a public key, etc.</returns>
public async Task <object> Find(string data)
{
data = data.Trim();
// Is it a Bitcoin address?
var b58 = NoException(() => WhatIsBase58.GetFromBitcoinString(data));
if (b58 != null)
{
if (b58 is WhatIsAddress address)
{
await TryFetchRedeemOrPubKey(address); // Shouldn't the return value here be checked?
}
return(b58);
}
// Is it a transaction ID?
if (data.Length == 0x40)
{
try
{
return(await Controller.JsonTransaction(uint256.Parse(data), false));
}
catch
{
// Well, apparently it's not a transaction ID.
}
}
// Is it a block feature?
var b = NoException(() => Controller.JsonBlock(BlockFeature.Parse(data), true, false));
if (b != null)
{
return(b);
}
// Is it the hash of a public key (modeled as KeyId in NBitcoin), or is it the hash of a script ID?
if (data.Length == 0x28) // Hash of pubkey or script
{
TxDestination dest = new KeyId(data);
var address = new WhatIsAddress(dest.GetAddress(Network));
if (await TryFetchRedeemOrPubKey(address))
{
return(address);
}
dest = new ScriptId(data);
address = new WhatIsAddress(dest.GetAddress(Network));
if (await TryFetchRedeemOrPubKey(address))
{
return(address);
}
}
// Is it a script?
var script = NoException(() => GetScriptFromBytes(data));
if (script != null)
{
return(new WhatIsScript(script, Network));
}
script = NoException(() => GetScriptFromText(data));
if (script != null)
{
return(new WhatIsScript(script, Network));
}
// Is it a transaction signature?
var sig = NoException(() => new TransactionSignature(Encoders.Hex.DecodeData(data)));
if (sig != null)
{
return(new WhatIsTransactionSignature(sig));
}
// Is it a hexstring representing the bytes of a public key?
var pubkeyBytes = NoException(() => Encoders.Hex.DecodeData(data));
if (pubkeyBytes != null && PubKey.Check(pubkeyBytes, true))
{
var pubKey = NoException(() => new PubKey(data));
if (pubKey != null)
{
return(new WhatIsPublicKey(pubKey, Network));
}
}
// Is it a blockheader?
if (data.Length == 80 * 2)
{
var blockHeader = NoException(() =>
{
var h = ConsensusFactory.CreateBlockHeader();
h.ReadWrite(Encoders.Hex.DecodeData(data), ConsensusFactory);
return(h);
});
if (blockHeader != null)
{
return(new WhatIsBlockHeader(blockHeader));
}
}
// No idea what this is.
return(null);
}
public static bool VerifySignature(uint256 message, UnblindedSignature signature, PubKey signerPubKey)
{
if (!Context.Instance.TryCreatePubKey(signerPubKey.ToBytes(), out var signerECPubkey))
{
throw new FormatException("Invalid signer pubkey.");
}
var p = signerECPubkey.Q;
var sG = (signature.S * EC.G).ToGroupElement();
var cP = p * signature.C;
var r = cP + sG;
var t = r.ToGroupElement().x.Normalize();
using var sha = new SHA256();
Span <byte> tmp = stackalloc byte[32];
message.ToBytes(tmp, false);
sha.Write(tmp);
t.WriteToSpan(tmp);
sha.Write(tmp);
sha.GetHash(tmp);
return(new Scalar(tmp) == signature.C);
}
public StealthPaymentScanner(BitField prefix, PubKey[] spendKeys, Key scan)
{
_Scan = scan;
_Prefix = prefix;
_SpendKeys = spendKeys.ToArray();
}
public uint256 BlindScript(PubKey signerPubKey, PubKey rPubKey, Script script)
{
var msg = new uint256(Hashes.SHA256(script.ToBytes()));
return(BlindMessage(msg, rPubKey, signerPubKey));
}
/// <summary>
/// Generates the scriptSig.
/// </summary>
/// <param name="signature">The transaction signature. For unsigned inputs this can be <c>null</c> in which case it is encoded as an <c>OP_0</c>.</param>
/// <param name="coldPubKey">A flag indicating whether the cold wallet versus the hot wallet is signing.</param>
/// <param name="publicKey">The cold or hot wallet public key.</param>
/// <returns>The scriptSig.</returns>
public Script GenerateScriptSig(TransactionSignature signature, bool coldPubKey, PubKey publicKey)
{
return(new Script(
Op.GetPushOp(signature.ToBytes()),
coldPubKey ? OpcodeType.OP_0 : OpcodeType.OP_1,
Op.GetPushOp(publicKey.ToBytes())
));
}
public uint256 BlindMessage(uint256 message, PubKey rpubkey, PubKey signerPubKey)
{
var ctx = new ECMultGenContext();
Span <byte> tmp = stackalloc byte[32];
if (!Context.Instance.TryCreatePubKey(signerPubKey.ToBytes(), out var signerECPubkey))
{
throw new FormatException("Invalid signer pubkey.");
}
if (!Context.Instance.TryCreatePubKey(rpubkey.ToBytes(), out var rECPubKey))
{
throw new FormatException("Invalid r pubkey.");
}
var p = signerECPubkey.Q;
var r = rECPubKey.Q.ToGroupElementJacobian();
var t = FE.Zero;
retry:
RandomUtils.GetBytes(tmp);
_v = new Scalar(tmp, out int overflow);
if (overflow != 0 || _v.IsZero)
{
goto retry;
}
RandomUtils.GetBytes(tmp);
_w = new Scalar(tmp, out overflow);
if (overflow != 0 || _v.IsZero)
{
goto retry;
}
var a1 = ctx.MultGen(_v);
var a2 = _w * p;
var a = r.AddVariable(a1, out _).AddVariable(a2, out _).ToGroupElement();
t = a.x.Normalize();
if (t.IsZero)
{
goto retry;
}
using (var sha = new SHA256())
{
message.ToBytes(tmp, false);
sha.Write(tmp);
t.WriteToSpan(tmp);
sha.Write(tmp);
sha.GetHash(tmp);
}
_c = new Scalar(tmp, out overflow);
if (overflow != 0 || _c.IsZero)
{
goto retry;
}
var cp = _c + _w.Negate(); // this is sent to the signer (blinded message)
if (cp.IsZero)
{
goto retry;
}
cp.WriteToSpan(tmp);
return(new uint256(tmp));
}
private void RemoveFederationMember(byte[] pubKeyBytes)
{
var key = new PubKey(pubKeyBytes);
this.federationManager.RemoveFederationMember(key);
}
public BitcoinStealthAddress(PubKey scanKey, PubKey[] pubKeys, int signatureCount, BitField bitfield, Network network)
: base(GenerateBytes(scanKey, pubKeys, bitfield, signatureCount), network)
{
}
static void Main(string[] args)
{
Key privateKey = new Key();
// Generting Bitcoin Secret from Private Key for the Main Network
BitcoinSecret mainNetPrivateKey = privateKey.GetBitcoinSecret(Network.Main);
// Generting Bitcoin Secret from Private Key for the Test Network
BitcoinSecret testNetPrivateKey = privateKey.GetBitcoinSecret(Network.TestNet);
Console.WriteLine(mainNetPrivateKey);
Console.WriteLine(testNetPrivateKey);
bool WifISBitcoinSecret = mainNetPrivateKey == privateKey.GetWif(Network.Main);
Console.WriteLine(WifISBitcoinSecret);
//Generating Private Key from Bitcoin Secret
Key samePrivateKey = mainNetPrivateKey.PrivateKey;
Console.WriteLine(samePrivateKey == privateKey);
PubKey publicKey = privateKey.PubKey;
BitcoinPubKeyAddress bitcoinPublicKey = publicKey.GetAddress(Network.Main);
//Not possible to get the Public Key from Bitcoin Address
//Generting Bitcoin Address
Console.WriteLine(publicKey);
Console.WriteLine(publicKey.GetAddress(Network.Main)); //Using Main Network
Console.WriteLine(publicKey.GetAddress(Network.TestNet)); //Using TestNet Network
var publicKeyHash = publicKey.Hash;
Console.WriteLine(publicKeyHash);
var mainNetAddress = publicKeyHash.GetAddress(Network.Main); //Using Main Network
var testNetAddress = publicKeyHash.GetAddress(Network.TestNet); //Using TestNet Network
Console.WriteLine(mainNetAddress);
Console.WriteLine(testNetAddress);
//Generating ScriptPubKey from Bitcoin Address
Console.WriteLine(mainNetAddress.ScriptPubKey);
Console.WriteLine(testNetAddress.ScriptPubKey);
//Generating Public Bitcoin Address from ScriptPubKey
var paymentScript = publicKeyHash.ScriptPubKey;
var sameMainNetAddress = paymentScript.GetDestinationAddress(Network.Main);
//True: Bitcoin Address for Main is same as Bitcoin Address Generated from ScriptPubKey
Console.WriteLine(mainNetAddress == sameMainNetAddress);
//Generating Public Key Hash from ScriptPubKey
var samePublicKeyHash = (KeyId)paymentScript.GetDestination();
//True: Public Key Hash is same as public key has generated from ScriptPubKey
Console.WriteLine(publicKeyHash == samePublicKeyHash);
var sameMainNetAddress2 = new BitcoinPubKeyAddress(samePublicKeyHash, Network.Main);
Console.WriteLine(mainNetAddress == sameMainNetAddress2); //True
Transaction tx = new Transaction("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");
Console.WriteLine(tx);
Console.ReadLine();
}
public static Gen <Script> FromKey(PubKey key)
{
return(Gen.Constant(new Script()));
}
private static Gen <TxOut> OutputFromKey(PubKey key) =>
from money in MoneyGenerator.Money()
from isP2WPKH in PrimitiveGenerator.Bool()
from isP2SH in PrimitiveGenerator.Bool()
let scriptPubKey = (isP2SH && isP2WPKH) ? key.WitHash.ScriptPubKey.Hash.ScriptPubKey : isP2WPKH ? key.WitHash.ScriptPubKey : key.Hash.ScriptPubKey
select new TxOut(money, scriptPubKey);
public bool CheckSignature(PubKey key)
{
if (key == null) throw new ArgumentNullException("key");
return key.Verify(Hashes.Hash256(payload.GetString()), signature.GetString());
}
public PubKeyScanner(PubKey pubKey)
{
_PubKey = pubKey;
}
public void CanUseSegwitAddress()
{
var address = (BitcoinWitPubKeyAddress)BitcoinAddress.Create("p2xuirpcDHjyETjKozsw1S19Hs23q6wJxvvX");
Assert.Equal("00140db804a04a249f53c53e1b3619a1411b4c41e2e2", address.ScriptPubKey.ToHex());
Assert.Equal("00140db804a04a249f53c53e1b3619a1411b4c41e2e2", address.Hash.ScriptPubKey.ToHex());
Assert.Equal("MUGbdic7BDYtn2K7TVyk47aArXKGk9XC1j", address.GetScriptAddress().ToString());
Assert.Equal("a914df70747a4fce42b9f8dc62318da432d067669eff87", address.GetScriptAddress().ScriptPubKey.ToHex());
//Example of the BIP
var pubkey = new PubKey("0450863AD64A87AE8A2FE83C1AF1A8403CB53F53E486D8511DAD8A04887E5B23522CD470243453A299FA9E77237716103ABC11A1DF38855ED6F2EE187E9C582BA6");
Assert.Equal(new Script("OP_0 010966776006953D5567439E5E39F86A0D273BEE"), pubkey.GetSegwitAddress(Network.Main).ScriptPubKey);
Assert.Equal("YMeG5MzsnmVKk86fzdjzhfJ5FXmexT8gvwi5", pubkey.GetSegwitAddress(Network.Main).ToString());
}
public static EscrowScriptPubKeyParameters ExtractEscrowScriptPubKeyParameters(Script script)
{
var ops = script.ToOps().ToArray();
if (ops.Length != 16)
{
return(null);
}
try
{
if (ops[0].Code != OpcodeType.OP_DEPTH ||
ops[1].Code != OpcodeType.OP_3 ||
ops[2].Code != OpcodeType.OP_EQUAL ||
ops[3].Code != OpcodeType.OP_IF ||
ops[4].Code != OpcodeType.OP_2)
{
return(null);
}
var k1 = new PubKey(ops[5].PushData);
var k2 = new PubKey(ops[6].PushData);
if (ops[7].Code != OpcodeType.OP_2 ||
ops[8].Code != OpcodeType.OP_CHECKMULTISIG ||
ops[9].Code != OpcodeType.OP_ELSE)
{
return(null);
}
var timeout = new LockTime((uint)ops[10].GetLong().Value);
if (ops[11].Code != OpcodeType.OP_CHECKLOCKTIMEVERIFY ||
ops[12].Code != OpcodeType.OP_DROP)
{
return(null);
}
var redeem = new PubKey(ops[13].PushData);
if (ops[14].Code != OpcodeType.OP_CHECKSIG ||
ops[15].Code != OpcodeType.OP_ENDIF)
{
return(null);
}
var keys = new[] { k1, k2 };
var orderedKeys = keys.OrderBy(o => o.ToHex()).ToArray();
if (!keys.SequenceEqual(orderedKeys))
{
return(null);
}
return(new EscrowScriptPubKeyParameters
{
EscrowKeys = new[] { k1, k2 },
LockTime = timeout,
RedeemKey = redeem
});
}
catch
{
return(null);
}
}
public BitcoinBlindedAddress(string base58, Network network)
: base(base58, network)
{
var prefix = network.GetVersionBytes(Base58Type.BLINDED_ADDRESS, true);
var version = network.GetVersionBytes(Base58Type.PUBKEY_ADDRESS, false);
var blech32 = network.GetBech32Encoder(Bech32Type.BLINDED_ADDRESS, false);
if (blech32 != null && NBitcoin.DataEncoders.Encoders.ASCII
.DecodeData(base58.Substring(0, blech32.HumanReadablePart.Length))
.SequenceEqual(blech32.HumanReadablePart))
{
var vchData = blech32.Decode(base58, out var witnessVerion);
bool p2pkh = !(version == null || !StartWith(prefix.Length, vchData, version));
var script = false;
var blinding = vchData.SafeSubarray(0, 33);
byte[] hash;
if (vchData.Length == 53)
{
hash = vchData.SafeSubarray(version.Length + 32, 20);
}
else
{
hash = vchData.SafeSubarray(version.Length + 32, vchData.Length - version.Length - 32);
script = true;
}
if (PubKey.Check(blinding, true))
{
_BlindingKey = new PubKey(blinding);
if (witnessVerion == 0)
{
_UnblindedAddress = script? (BitcoinAddress) new BitcoinWitScriptAddress(new WitScriptId(hash), network): new BitcoinWitPubKeyAddress(new WitKeyId(hash), network);
}
else if (witnessVerion > 16 || hash.Length < 2 || hash.Length > 40)
{
throw new FormatException("Invalid Bitcoin Blinded Address");
}
}
else
{
throw new FormatException("Invalid Bitcoin Blinded Address");
}
}
else
{
var vchData = NBitcoin.DataEncoders.Encoders.Base58Check.DecodeData(base58);
bool p2pkh = true;
if (version == null || !StartWith(prefix.Length, vchData, version))
{
p2pkh = false;
version = network.GetVersionBytes(Base58Type.SCRIPT_ADDRESS, false);
if (version == null || !StartWith(prefix.Length, vchData, version))
{
throw new FormatException("Invalid Bitcoin Blinded Address");
}
}
if (vchData.Length != prefix.Length + version.Length + 33 + 20)
{
throw new FormatException("Invalid Bitcoin Blinded Address");
}
var blinding = vchData.SafeSubarray(prefix.Length + version.Length, 33);
if (PubKey.Check(blinding, true))
{
_BlindingKey = new PubKey(blinding);
var hash = vchData.SafeSubarray(prefix.Length + version.Length + 33, 20);
_UnblindedAddress =
p2pkh
? (BitcoinAddress) new BitcoinPubKeyAddress(new KeyId(hash), network)
: new BitcoinScriptAddress(new ScriptId(hash), network);
}
else
{
throw new FormatException("Invalid Bitcoin Blinded Address");
}
}
}
public void CanGenerateScriptFromAddress()
{
var address = new BitcoinPubKeyAddress(new KeyId("47376c6f537d62177a2c41c4ca9b45829ab99083"), Network.Main);
Assert.Equal("OP_DUP OP_HASH160 47376c6f537d62177a2c41c4ca9b45829ab99083 OP_EQUALVERIFY OP_CHECKSIG", address.ScriptPubKey.ToString());
var scriptAddress = new BitcoinScriptAddress(new ScriptId("8f55563b9a19f321c211e9b9f38cdf686ea07845"), Network.Main);
Assert.Equal("OP_HASH160 8f55563b9a19f321c211e9b9f38cdf686ea07845 OP_EQUAL", scriptAddress.ScriptPubKey.ToString());
var pubKey = new PubKey("0359d3092e4a8d5f3b3948235b5dec7395259273ccf3c4e9d5e16695a3fc9588d6");
Assert.Equal("OP_DUP OP_HASH160 4d29186f76581c7375d70499afd1d585149d42cd OP_EQUALVERIFY OP_CHECKSIG", pubKey.Hash.ScriptPubKey.ToString());
Assert.Equal("0359d3092e4a8d5f3b3948235b5dec7395259273ccf3c4e9d5e16695a3fc9588d6 OP_CHECKSIG", pubKey.ScriptPubKey.ToString());
Script script = new Script("0359d3092e4a8d5f3b3948235b5dec7395259273ccf3c4e9d5e16695a3fc9588d6 OP_CHECKSIG");
Assert.Equal("OP_HASH160 a216e3bce8c1b3adf376731b6cd0b6936c4e053f OP_EQUAL", script.PaymentScript.ToString());
}
public object Find(string data)
{
data = data.Trim();
var b58 = NoException(() => WhatIsBase58.GetFromBase58Data(data));
if (b58 != null)
{
if (b58 is WhatIsAddress)
{
var address = (WhatIsAddress)b58;
TryFetchRedeemOrPubKey(address);
}
return(b58);
}
if (data.Length == 0x40)
{
var tx = NoException(() => Controller.JsonTransaction(new uint256(data)));
if (tx != null)
{
return(tx);
}
}
var b = NoException(() => Controller.JsonBlock(BlockFeature.Parse(data), true));
if (b != null)
{
return(b);
}
if (data.Length == 0x28) //Hash of pubkey or script
{
TxDestination dest = new KeyId(data);
var address = new WhatIsAddress(dest.GetAddress(Network));
if (TryFetchRedeemOrPubKey(address))
{
return(address);
}
dest = new ScriptId(data);
address = new WhatIsAddress(dest.GetAddress(Network));
if (TryFetchRedeemOrPubKey(address))
{
return(address);
}
}
var script = NoException(() => GetScriptFromBytes(data));
if (script != null)
{
return(new WhatIsScript(script, Network));
}
script = NoException(() => GetScriptFromText(data));
if (script != null)
{
return(new WhatIsScript(script, Network));
}
var sig = NoException(() => new TransactionSignature(Encoders.Hex.DecodeData(data)));
if (sig != null)
{
return(new WhatIsTransactionSignature(sig));
}
var pubkeyBytes = NoException(() => Encoders.Hex.DecodeData(data));
if (pubkeyBytes != null && PubKey.Check(pubkeyBytes, true))
{
var pubKey = NoException(() => new PubKey(data));
if (pubKey != null)
{
return(new WhatIsPublicKey(pubKey, Network));
}
}
if (data.Length == 80 * 2)
{
var blockHeader = NoException(() =>
{
var h = new BlockHeader();
h.ReadWrite(Encoders.Hex.DecodeData(data));
return(h);
});
if (blockHeader != null)
{
return(new WhatIsBlockHeader(blockHeader));
}
}
return(null);
}
public BitcoinStealthAddress(PubKey scanKey, PubKey[] pubKeys, int signatureCount, BitField bitfield, Network network)
: base(GenerateBytes(scanKey, pubKeys, bitfield, signatureCount), network)
{
}
public async Task <ISegwitPrivateWallet> CreateSegwitWallet()
{
var segwitPubKey = new PubKey(await _signatureApiProvider.GeneratePubKey());
return(await CreateSegwitWallet(segwitPubKey));
}
public static Script CreatePaymentScript(int sigCount, PubKey[] spendPubKeys, Key ephemKey, PubKey scanPubKey)
{
return CreatePaymentScript(sigCount, spendPubKeys.Select(p => p.Uncover(ephemKey, scanPubKey)).ToArray());
}
public static bool VerifySignature(uint256 message, UnblindedSignature signature, PubKey signerPubKey)
{
var P = signerPubKey.ECKey.GetPublicKeyParameters().Q;
var sG = Secp256k1.G.Multiply(signature.S);
var cP = P.Multiply(signature.C);
var R = cP.Add(sG).Normalize();
var t = R.AffineXCoord.ToBigInteger().Mod(Secp256k1.N);
var c = new BigInteger(1, Hashes.SHA256(message.ToBytes(false).Concat(Utils.BigIntegerToBytes(t, 32))));
return(c.Equals(signature.C));
}
public static Script CreatePaymentScript(BitcoinStealthAddress address, PubKey ephemKey, Key scan)
{
return CreatePaymentScript(address.SignatureCount, address.SpendPubKeys.Select(p => p.UncoverReceiver(scan, ephemKey)).ToArray());
}
public uint256 BlindMessage(byte[] message, PubKey rpubKey, PubKey signerPubKey)
{
var msg = new uint256(Hashes.SHA256(message));
return(BlindMessage(msg, rpubKey, signerPubKey));
}
private void AssertHasAsset(Transaction tx, ColoredTransaction colored, ColoredEntry entry, AssetId assetId, int quantity, PubKey destination)
{
var txout = tx.Outputs[entry.Index];
Assert.True(entry.Asset.Id == assetId);
Assert.True(entry.Asset.Quantity == quantity);
if(destination != null)
Assert.True(txout.ScriptPubKey == destination.ScriptPubKey);
}
public bool CheckSignature(PubKey key)
{
return key.Verify(Hashes.Hash256(payload.GetString()), signature.GetString());
}
private Key AssertKeys(string key, string pub)
{
if(key == null)
return null;
Key k = new Key(TestUtils.ParseHex(key));
if(pub != null)
{
PubKey p = new PubKey(TestUtils.ParseHex(pub));
AssertEx.Equal(k.PubKey.ToBytes(), p.ToBytes());
}
return k;
}
public Transaction CreateColdStakingWithdrawalTransaction(Wallet.Types.Wallet wallet, string password, HdAddress spendingAddress, PubKey destinationPubKey, Script changeScript, Money amount, Money fee)
{
TransactionOutputData spendingTransaction = wallet.walletStore.GetForAddress(spendingAddress.Address).ElementAt(0);
var coin = new Coin(spendingTransaction.Id, (uint)spendingTransaction.Index, spendingTransaction.Amount, spendingTransaction.ScriptPubKey);
Key privateKey = Key.Parse(wallet.EncryptedSeed, password, wallet.Network);
Script script = destinationPubKey.ScriptPubKey;
var builder = new TransactionBuilder(wallet.Network);
builder.Extensions.Add(new ColdStakingBuilderExtension(false));
Transaction tx = builder
.AddCoins(new List <Coin> {
coin
})
.AddKeys(new ExtKey(privateKey, wallet.ChainCode).Derive(new KeyPath(spendingAddress.HdPath)).GetWif(wallet.Network))
.Send(script, amount)
.SetChange(changeScript)
.SendFees(fee)
.BuildTransaction(true);
if (!builder.Verify(tx))
{
throw new WalletException("Could not build transaction, please make sure you entered the correct data.");
}
return(tx);
}
