public static bool TryParse(string str, out PartialSignature?sig) { if (str == null) { throw new ArgumentNullException(nameof(str)); } sig = null; try { var bytes = Encoders.Hex.DecodeData(str); if (bytes.Length < 2 + 33 + 1 || bytes[0] != 0x22 || bytes[1] != 0x02) { return(false); } var pk = new NBitcoin.PubKey(bytes.AsSpan().Slice(2, 33).ToArray()); var siglen = bytes[2 + 33]; if (siglen < 75 && bytes.Length != 2 + 33 + 1 + siglen) { return(false); } var sigBytes = bytes.AsSpan().Slice(2 + 33 + 1).ToArray(); if (!TransactionSignature.IsValid(sigBytes)) { return(false); } var s = new TransactionSignature(sigBytes); sig = new PartialSignature(pk, s); return(true); } catch { return(false); } }
public static StealthPayment[] GetPayments(Transaction transaction, PubKey[] spendKeys, BitField bitField, Key scan) { List<StealthPayment> result = new List<StealthPayment>(); for(int i = 0 ; i < transaction.Outputs.Count ; i++) { var metadata = StealthMetadata.TryParse(transaction.Outputs[i].ScriptPubKey); if(metadata != null && bitField.Match(metadata.BitField)) { var payment = new StealthPayment(transaction.Outputs[i + 1].ScriptPubKey, metadata); if(scan != null && spendKeys != null) { if(payment.StealthKeys.Length != spendKeys.Length) continue; var expectedStealth = spendKeys.Select(s => s.UncoverReceiver(scan, metadata.EphemKey)).ToList(); foreach(var stealth in payment.StealthKeys) { var match = expectedStealth.FirstOrDefault(expected => expected.ID == stealth.ID); if(match != null) expectedStealth.Remove(match); } if(expectedStealth.Count != 0) continue; } result.Add(payment); } } return result.ToArray(); }
public bool Check(PubKey pubKey, Script scriptPubKey, Transaction tx, uint nIndex, ScriptVerify verify = ScriptVerify.Standard) { return new ScriptEvaluationContext() { ScriptVerify = verify, SigHash = SigHash }.CheckSig(this, pubKey, scriptPubKey, tx, nIndex); }
public BitcoinOracleConnector(string network, string endpoint, string pkcsUser, string hsmKey) { this.pkcsUser = pkcsUser; this.hsmKey = hsmKey; this.network = network == "testnet" ? NetworkType.Testnet : NetworkType.Mainnet; client = new ExplorerClient(new NBXplorerNetworkProvider(this.network).GetBTC(), new Uri(endpoint)); pubKey = new NBitcoin.PubKey("045138d46c0e99a3b94a49551581097bae7162bdbd70dbddc580963f98b2771bbee5ecf367dfa34b2c9952269691f87153cbf2a1589c177dfd66ac6735b92f6cf7"); }
public GetWalletPubKeyResponse(byte[] bytes) { MemoryStream ms = new MemoryStream(bytes); var len = ms.ReadByte(); UncompressedPublicKey = new PubKey(ms.ReadBytes(len)); len = ms.ReadByte(); var addr = Encoding.ASCII.GetString(ms.ReadBytes(len)); Address = BitcoinAddress.GetFromBase58Data(addr); ChainCode = ms.ReadBytes(32); }
static Coin CreateTransactionFeeCoin(PubKey destination, NoSqlTransactionRepository txRepo) { var bitcoinProviderTransaction = new Transaction() { Outputs = { new TxOut("0.0001" , destination) } }; txRepo.Put(bitcoinProviderTransaction.GetHash(), bitcoinProviderTransaction); return new Coin(new OutPoint(bitcoinProviderTransaction, 0), bitcoinProviderTransaction.Outputs[0]); }
public StealthPayment(int sigCount, PubKey[] spendPubKeys, Key privateKey, PubKey publicKey, StealthMetadata metadata) { Metadata = metadata; if(sigCount == 1 && spendPubKeys.Length == 1) { var template = new PayToPubkeyHashTemplate(); SpendableScript = template.GenerateScriptPubKey(spendPubKeys[0].Uncover(privateKey, publicKey).ID); } else { var template = new PayToMultiSigTemplate(); SpendableScript = template.GenerateScriptPubKey(sigCount, spendPubKeys.Select(p => p.Uncover(privateKey, publicKey)).ToArray()); } ParseSpendable(); }
public bool Check(PubKey pubKey, Script scriptPubKey, IndexedTxIn txIn, ScriptVerify verify = ScriptVerify.Standard) { return Check(pubKey, scriptPubKey, txIn.Transaction, txIn.Index, verify); }
public PubKey Uncover(Key priv, PubKey pub) { var curve = ECKey.CreateCurve(); var hash = GetStealthSharedSecret(priv,pub); //Q' = Q + cG var qprim = curve.G.Multiply(new BigInteger(1, hash)).Add(curve.Curve.DecodePoint(this.ToBytes())); return new PubKey(qprim.GetEncoded()).Compress(this.IsCompressed); }
public PubKey UncoverSender(Key ephem, PubKey scan) { return Uncover(ephem, scan); }
public bool Check(Network network, PubKey pubKey, Script scriptPubKey, IndexedTxIn txIn, ScriptVerify verify = ScriptVerify.Standard) { return(this.Check(network, pubKey, scriptPubKey, txIn.Transaction, txIn.Index, verify)); }
public bool Check(string passphrase, BitcoinAddress expectedAddress) { //Derive passfactor using scrypt with ownerentropy and the user's passphrase and use it to recompute passpoint byte[] passfactor = BitcoinEncryptedSecretEC.CalculatePassFactor(passphrase, LotSequence, OwnerEntropy); //Derive decryption key for pointb using scrypt with passpoint, addresshash, and ownerentropy byte[] passpoint = BitcoinEncryptedSecretEC.CalculatePassPoint(passfactor); byte[] derived = BitcoinEncryptedSecretEC.CalculateDecryptionKey(passpoint, AddressHash, OwnerEntropy); //Decrypt encryptedpointb to yield pointb var pointbprefix = EncryptedPointB[0]; pointbprefix = (byte)(pointbprefix ^ (byte)(derived[63] & (byte)0x01)); //Optional since ArithmeticException will catch it, but it saves some times if(pointbprefix != 0x02 && pointbprefix != 0x03) return false; var pointb = BitcoinEncryptedSecret.DecryptKey(EncryptedPointB.Skip(1).ToArray(), derived); pointb = new byte[] { pointbprefix }.Concat(pointb).ToArray(); //4.ECMultiply pointb by passfactor. Use the resulting EC point as a public key var curve = ECKey.CreateCurve(); ECPoint pointbec = null; try { pointbec = curve.Curve.DecodePoint(pointb); } catch(ArithmeticException) { return false; } PubKey pubkey = new PubKey(pointbec.Multiply(new BigInteger(1, passfactor)).GetEncoded()); //and hash it into address using either compressed or uncompressed public key methodology as specifid in flagbyte. pubkey = IsCompressed ? pubkey.Compress() : pubkey.Decompress(); var actualhash = BitcoinEncryptedSecretEC.HashAddress(pubkey.GetAddress(Network)); var expectedhash = BitcoinEncryptedSecretEC.HashAddress(expectedAddress); return Utils.ArrayEqual(actualhash, expectedhash); }
public Script GenerateScriptPubKey(int sigCount, PubKey[] keys) { List<Op> ops = new List<Op>(); var push = Op.GetPushOp(sigCount); if(!push.IsSmallUInt) throw new ArgumentOutOfRangeException("sigCount should be less or equal to 16"); ops.Add(push); var keyCount = Op.GetPushOp(keys.Length); if(!keyCount.IsSmallUInt) throw new ArgumentOutOfRangeException("key count should be less or equal to 16"); foreach(var key in keys) { ops.Add(Op.GetPushOp(key.ToBytes())); } ops.Add(keyCount); ops.Add(OpcodeType.OP_CHECKMULTISIG); return new Script(ops.ToArray()); }
public Block CreateNextBlockWithCoinbase(PubKey pubkey, Money value, DateTimeOffset now) { Block block = new Block(); block.Header.Nonce = RandomUtils.GetUInt32(); block.Header.HashPrevBlock = this.GetHash(); block.Header.BlockTime = now; var tx = block.AddTransaction(new Transaction()); tx.AddInput(new TxIn() { ScriptSig = new Script(Op.GetPushOp(RandomUtils.GetBytes(30))) }); tx.Outputs.Add(new TxOut() { Value = value, ScriptPubKey = PayToPubkeyHashTemplate.Instance.GenerateScriptPubKey(pubkey) }); return block; }
public PubKey UncoverReceiver(Key scan, PubKey ephem) { return(Uncover(scan, ephem)); }
public BitcoinStealthAddress CreateStealthAddress(PubKey scanKey, Network network) { return(new BitcoinStealthAddress(scanKey, new PubKey[] { this }, 1, null, network)); }
public bool VerifyMessage(string message, string signature) { var key = PubKey.RecoverFromMessage(message, signature); return(key.ID == ID); }
public PubKey UncoverSender(Key ephem, PubKey scan) { return(Uncover(ephem, scan)); }
public static Script PayToPubkey(PubKey pubkey) { return(PayToPubkeyTemplate.Instance.GenerateScriptPubKey(pubkey)); }
private bool CheckWitScriptCore(WitScript witScript) { return(witScript.PushCount == 2 && ((witScript[0].Length == 1 && witScript[0][0] == 0) || (TransactionSignature.IsValid(witScript[0], ScriptVerify.None))) && PubKey.Check(witScript[1], false)); }
/// <summary> /// Add keypath information to this PSBT for each input or output involving it /// </summary> /// <param name="pubkey">The public key which need to sign</param> /// <param name="rootedKeyPath">The keypath to this public key</param> /// <returns>This PSBT</returns> public PSBT AddKeyPath(PubKey pubkey, RootedKeyPath rootedKeyPath) { return(AddKeyPath(pubkey, rootedKeyPath, null)); }
public Key GetKey(PubKey pubKey) { return _Keys.FirstOrDefault(k => k.PubKey == pubKey); }
private Key FindKey(TransactionSigningContext ctx, PubKey pubKey) { return(_Keys .Concat(ctx.AdditionalKeys) .FirstOrDefault(k => k.PubKey == pubKey)); }
public static Script PayToPubkey(PubKey pubkey) { return new PayToPubkeyTemplate().GenerateScriptPubKey(pubkey); }
public static bool VerifyMessage(this BitcoinWitPubKeyAddress address, uint256 messageHash, byte[] signature) { PubKey pubKey = PubKey.RecoverCompact(messageHash, signature); return(pubKey.WitHash == address.Hash); }
public EncryptedKeyResult GenerateEncryptedSecret(bool isCompressed = true, byte[] seedb = null) { //Set flagbyte. byte flagByte = 0; //Turn on bit 0x20 if the Bitcoin address will be formed by hashing the compressed public key flagByte |= isCompressed ? (byte)0x20 : (byte)0x00; flagByte |= LotSequence != null ? (byte)0x04 : (byte)0x00; //Generate 24 random bytes, call this seedb. Take SHA256(SHA256(seedb)) to yield 32 bytes, call this factorb. seedb = seedb ?? RandomUtils.GetBytes(24); var factorb = Hashes.Hash256(seedb).ToBytes(); //ECMultiply passpoint by factorb. var curve = ECKey.Secp256k1; var passpoint = curve.Curve.DecodePoint(Passpoint); var pubPoint = passpoint.Multiply(new BigInteger(1, factorb)); //Use the resulting EC point as a public key var pubKey = new PubKey(pubPoint.GetEncoded()); //and hash it into a Bitcoin address using either compressed or uncompressed public key //This is the generated Bitcoin address, call it generatedaddress. pubKey = isCompressed ? pubKey.Compress() : pubKey.Decompress(); //call it generatedaddress. var generatedaddress = pubKey.GetAddress(ScriptPubKeyType.Legacy, Network); //Take the first four bytes of SHA256(SHA256(generatedaddress)) and call it addresshash. var addresshash = BitcoinEncryptedSecretEC.HashAddress(generatedaddress); //Derive a second key from passpoint using scrypt //salt is addresshash + ownerentropy var derived = BitcoinEncryptedSecretEC.CalculateDecryptionKey(Passpoint, addresshash, OwnerEntropy); //Now we will encrypt seedb. var encrypted = BitcoinEncryptedSecret.EncryptSeed (seedb, derived); //0x01 0x43 + flagbyte + addresshash + ownerentropy + encryptedpart1[0...7] + encryptedpart2 which totals 39 bytes var bytes = new[] { flagByte } .Concat(addresshash) .Concat(this.OwnerEntropy) .Concat(encrypted.Take(8).ToArray()) .Concat(encrypted.Skip(16).ToArray()) .ToArray(); var encryptedSecret = new BitcoinEncryptedSecretEC(bytes, Network); return(new EncryptedKeyResult(encryptedSecret, generatedaddress, seedb, () => { //ECMultiply factorb by G, call the result pointb. The result is 33 bytes. var pointb = new Key(factorb).PubKey.ToBytes(); //The first byte is 0x02 or 0x03. XOR it by (derivedhalf2[31] & 0x01), call the resulting byte pointbprefix. var pointbprefix = (byte)(pointb[0] ^ (byte)(derived[63] & 0x01)); var pointbx = BitcoinEncryptedSecret.EncryptKey(pointb.Skip(1).ToArray(), derived); var encryptedpointb = new byte[] { pointbprefix }.Concat(pointbx).ToArray(); var confirmBytes = Network.GetVersionBytes(Base58Type.CONFIRMATION_CODE, true) .Concat(new[] { flagByte }) .Concat(addresshash) .Concat(OwnerEntropy) .Concat(encryptedpointb) .ToArray(); return new BitcoinConfirmationCode(Network.NetworkStringParser.GetBase58CheckEncoder().EncodeData(confirmBytes), Network); })); }
public static uint256 BlindScript(this Requester requester, PubKey signerPubKey, PubKey RPubKey, Script script) { var msg = new uint256(Hashes.SHA256(script.ToBytes())); return(requester.BlindMessage(msg, RPubKey, signerPubKey)); }
Script Decompress(uint nSize, byte[] data) { switch(nSize) { case 0x00: return new Script(OpcodeType.OP_DUP, OpcodeType.OP_HASH160, Op.GetPushOp(data.Take(20).ToArray()), OpcodeType.OP_EQUALVERIFY, OpcodeType.OP_CHECKSIG); case 0x01: return new Script(OpcodeType.OP_HASH160, Op.GetPushOp(data.Take(20).ToArray()), OpcodeType.OP_EQUAL); case 0x02: case 0x03: return new Script(Op.GetPushOp(new byte[] { (byte)nSize }.Concat(data.Take(32)).ToArray()), OpcodeType.OP_CHECKSIG); case 0x04: case 0x05: byte[] vch = new byte[33]; vch[0] = (byte)(nSize - 2); Array.Copy(data, vch, 32); PubKey pubkey = new PubKey(vch); pubkey = pubkey.Decompress(); return new Script(Op.GetPushOp(pubkey.ToBytes()), OpcodeType.OP_CHECKSIG); } return null; }
public override int GetHashCode() { return(PubKey.GetHashCode()); }
public BitcoinStealthAddress(PubKey scanKey, PubKey[] pubKeys, int signatureCount, BitField bitfield, Network network) : base(GenerateBytes(scanKey, pubKeys, bitfield, signatureCount), network) { }
internal PSBTOutput(BitcoinStream stream, PSBT parent, uint index, TxOut txOut) : base(parent) { if (txOut == null) { throw new ArgumentNullException(nameof(txOut)); } if (parent == null) { throw new ArgumentNullException(nameof(parent)); } TxOut = txOut; Index = index; byte[] k = new byte[0]; byte[] v = new byte[0]; try { stream.ReadWriteAsVarString(ref k); } catch (EndOfStreamException e) { throw new FormatException("Invalid PSBTOutput. Could not read key", e); } while (k.Length != 0) { try { stream.ReadWriteAsVarString(ref v); } catch (EndOfStreamException e) { throw new FormatException("Invalid PSBTOutput. Could not read value", e); } switch (k.First()) { case PSBTConstants.PSBT_OUT_REDEEMSCRIPT: if (k.Length != 1) { throw new FormatException("Invalid PSBTOutput. Contains illegal value in key for redeem script"); } if (redeem_script != null) { throw new FormatException("Invalid PSBTOutput, duplicate key for redeem_script"); } redeem_script = Script.FromBytesUnsafe(v); break; case PSBTConstants.PSBT_OUT_WITNESSSCRIPT: if (k.Length != 1) { throw new FormatException("Invalid PSBTOutput. Contains illegal value in key for witness script"); } if (witness_script != null) { throw new FormatException("Invalid PSBTOutput, duplicate key for redeem_script"); } witness_script = Script.FromBytesUnsafe(v); break; case PSBTConstants.PSBT_OUT_BIP32_DERIVATION: var pubkey2 = new PubKey(k.Skip(1).ToArray()); if (hd_keypaths.ContainsKey(pubkey2)) { throw new FormatException("Invalid PSBTOutput, duplicate key for hd_keypaths"); } KeyPath path = KeyPath.FromBytes(v.Skip(4).ToArray()); hd_keypaths.Add(pubkey2, new RootedKeyPath(new HDFingerprint(v.Take(4).ToArray()), path)); break; default: if (unknown.ContainsKey(k)) { throw new FormatException("Invalid PSBTInput, duplicate key for unknown value"); } unknown.Add(k, v); break; } stream.ReadWriteAsVarString(ref k); } }
public BitcoinStealthAddress CreateStealthAddress(PubKey scanKey, Network network) { return new BitcoinStealthAddress(scanKey, new PubKey[] { this }, 1, null, network); }
public Block CreateNextBlockWithCoinbase(PubKey pubkey, Money value) { return(this.CreateNextBlockWithCoinbase(pubkey, value, DateTimeOffset.UtcNow)); }
public PubKey UncoverReceiver(Key scan, PubKey ephem) { return Uncover(scan, ephem); }
public override void AddKeyPath(HDFingerprint fingerprint, PubKey key, KeyPath path) { base.AddKeyPath(fingerprint, key, path); TrySlimOutput(); }
internal static byte[] GetStealthSharedSecret(Key priv, PubKey pub) { var curve = ECKey.CreateCurve(); var pubec = curve.Curve.DecodePoint(pub.ToBytes()); var p = pubec.Multiply(new BigInteger(1, priv.ToBytes())); var pBytes = new PubKey(p.GetEncoded()).Compress().ToBytes(); var hash = Hashes.SHA256(pBytes); return hash; }
internal PSBTInput(BitcoinStream stream, PSBT parent, uint index, TxIn input) : base(parent) { TxIn = input; Index = index; originalScriptSig = TxIn.ScriptSig ?? Script.Empty; originalWitScript = TxIn.WitScript ?? WitScript.Empty; byte[] k = new byte[0]; byte[] v = new byte[0]; try { stream.ReadWriteAsVarString(ref k); } catch (EndOfStreamException e) { throw new FormatException("Invalid PSBTInput. Failed to Parse key.", e); } while (k.Length != 0) { try { stream.ReadWriteAsVarString(ref v); } catch (EndOfStreamException e) { throw new FormatException("Invalid PSBTInput. Failed to parse key.", e); } switch (k.First()) { case PSBTConstants.PSBT_IN_NON_WITNESS_UTXO: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for NonWitnessUTXO"); } if (non_witness_utxo != null) { throw new FormatException("Invalid PSBTInput. Duplicate non_witness_utxo"); } non_witness_utxo = this.GetConsensusFactory().CreateTransaction(); non_witness_utxo.FromBytes(v); break; case PSBTConstants.PSBT_IN_WITNESS_UTXO: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for WitnessUTXO"); } if (witness_utxo != null) { throw new FormatException("Invalid PSBTInput. Duplicate witness_utxo"); } if (this.GetConsensusFactory().TryCreateNew <TxOut>(out var txout)) { witness_utxo = txout; } else { witness_utxo = new TxOut(); } witness_utxo.FromBytes(v); break; case PSBTConstants.PSBT_IN_PARTIAL_SIG: var pubkey = new PubKey(k.Skip(1).ToArray()); if (partial_sigs.ContainsKey(pubkey)) { throw new FormatException("Invalid PSBTInput. Duplicate key for partial_sigs"); } partial_sigs.Add(pubkey, new TransactionSignature(v)); break; case PSBTConstants.PSBT_IN_SIGHASH: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for SigHash type"); } if (!(sighash_type is null)) { throw new FormatException("Invalid PSBTInput. Duplicate key for sighash_type"); } if (v.Length != 4) { throw new FormatException("Invalid PSBTInput. SigHash Type is not 4 byte"); } var value = Utils.ToUInt32(v, 0, true); if (!Enum.IsDefined(typeof(SigHash), value)) { throw new FormatException($"Invalid PSBTInput Unknown SigHash Type {value}"); } sighash_type = (SigHash)value; break; case PSBTConstants.PSBT_IN_REDEEMSCRIPT: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for redeem script"); } if (redeem_script != null) { throw new FormatException("Invalid PSBTInput. Duplicate key for redeem_script"); } redeem_script = Script.FromBytesUnsafe(v); break; case PSBTConstants.PSBT_IN_WITNESSSCRIPT: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for witness script"); } if (witness_script != null) { throw new FormatException("Invalid PSBTInput. Duplicate key for redeem_script"); } witness_script = Script.FromBytesUnsafe(v); break; case PSBTConstants.PSBT_IN_BIP32_DERIVATION: var pubkey2 = new PubKey(k.Skip(1).ToArray()); if (hd_keypaths.ContainsKey(pubkey2)) { throw new FormatException("Invalid PSBTInput. Duplicate key for hd_keypaths"); } var masterFingerPrint = new HDFingerprint(v.Take(4).ToArray()); KeyPath path = KeyPath.FromBytes(v.Skip(4).ToArray()); hd_keypaths.Add(pubkey2, Tuple.Create(masterFingerPrint, path)); break; case PSBTConstants.PSBT_IN_SCRIPTSIG: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for final scriptsig"); } if (final_script_sig != null) { throw new FormatException("Invalid PSBTInput. Duplicate key for final_script_sig"); } final_script_sig = Script.FromBytesUnsafe(v); break; case PSBTConstants.PSBT_IN_SCRIPTWITNESS: if (k.Length != 1) { throw new FormatException("Invalid PSBTInput. Contains illegal value in key for final script witness"); } if (final_script_witness != null) { throw new FormatException("Invalid PSBTInput. Duplicate key for final_script_witness"); } final_script_witness = new WitScript(v); break; default: if (unknown.ContainsKey(k)) { throw new FormatException("Invalid PSBTInput. Duplicate key for unknown value"); } unknown.Add(k, v); break; } stream.ReadWriteAsVarString(ref k); } }
public Block CreateNextBlockWithCoinbase(PubKey pubkey, Money value, DateTimeOffset now) { return(CreateNextBlockWithCoinbase(pubkey, value, now, Consensus.Main.ConsensusFactory)); }
public ExtPubKey Derive(uint index) { var childPubKey = pubkey.Derivate(this.vchChainCode, index, out var chainCode); var result = new ExtPubKey(childPubKey, chainCode, (byte)(nDepth + 1), PubKey.GetHDFingerPrint(), index); return(result); }
public Block CreateNextBlockWithCoinbase(PubKey pubkey, Money value, ConsensusFactory consensusFactory) { return(CreateNextBlockWithCoinbase(pubkey, value, DateTimeOffset.UtcNow, consensusFactory)); }
public bool IsTo(PubKey pubkey) { return IsTo(pubkey.ID); }
public override void AddKeyPath(PubKey key, RootedKeyPath rootedKeyPath) { base.AddKeyPath(key, rootedKeyPath); TrySlimUTXO(); }
public Key Uncover(Key scan, PubKey ephem) { var curve = ECKey.Secp256k1; var priv = new BigInteger(1, PubKey.GetStealthSharedSecret(scan, ephem)) .Add(new BigInteger(1, this.ToBytes())) .Mod(curve.N) .ToByteArrayUnsigned(); if(priv.Length < 32) priv = new byte[32 - priv.Length].Concat(priv).ToArray(); var key = new Key(priv, fCompressedIn: this.IsCompressed); return key; }
public Script GenerateScriptSig(TransactionSignature signature, PubKey publicKey) { if(signature == null) throw new ArgumentNullException("signature"); if(publicKey == null) throw new ArgumentNullException("publicKey"); return new Script( Op.GetPushOp(signature.ToBytes()), Op.GetPushOp(publicKey.ToBytes()) ); }
public Script GenerateScriptPubKey(PubKey pubKey) { if(pubKey == null) throw new ArgumentNullException("pubKey"); return GenerateScriptPubKey(pubKey.WitHash); }
public Block CreateNextBlockWithCoinbase(PubKey pubkey, Money value) { return CreateNextBlockWithCoinbase(pubkey, value, DateTimeOffset.UtcNow); }
public bool IsFrom(PubKey pubKey) { var result = PayToPubkeyHashTemplate.Instance.ExtractScriptSigParameters(ScriptSig); return(result != null && result.PublicKey == pubKey); }
public PubKey[] Uncover(PubKey[] spendPubKeys, Key scanKey) { var pubKeys = new PubKey[spendPubKeys.Length]; for(int i = 0 ; i < pubKeys.Length ; i++) { pubKeys[i] = spendPubKeys[i].UncoverReceiver(scanKey, StealthMetadata.EphemKey); } return pubKeys; }
public EncryptedKeyResult GenerateEncryptedSecret(bool isCompressed = true, byte[] seedb = null) { //Set flagbyte. byte flagByte = 0; //Turn on bit 0x20 if the Bitcoin address will be formed by hashing the compressed public key flagByte |= isCompressed ? (byte)0x20 : (byte)0x00; flagByte |= LotSequence != null ? (byte)0x04 : (byte)0x00; //Generate 24 random bytes, call this seedb. Take SHA256(SHA256(seedb)) to yield 32 bytes, call this factorb. seedb = seedb ?? RandomUtils.GetBytes(24); var factorb = Hashes.Hash256(seedb).ToBytes(); //ECMultiply passpoint by factorb. var curve = ECKey.Secp256k1; var passpoint = curve.Curve.DecodePoint(Passpoint); var pubPoint = passpoint.Multiply(new BigInteger(1, factorb)); //Use the resulting EC point as a public key var pubKey = new PubKey(pubPoint.GetEncoded()); //and hash it into a Bitcoin address using either compressed or uncompressed public key //This is the generated Bitcoin address, call it generatedaddress. pubKey = isCompressed ? pubKey.Compress() : pubKey.Decompress(); //call it generatedaddress. var generatedaddress = pubKey.GetAddress(Network); //Take the first four bytes of SHA256(SHA256(generatedaddress)) and call it addresshash. var addresshash = BitcoinEncryptedSecretEC.HashAddress(generatedaddress); //Derive a second key from passpoint using scrypt //salt is addresshash + ownerentropy var derived = BitcoinEncryptedSecretEC.CalculateDecryptionKey(Passpoint, addresshash, OwnerEntropy); //Now we will encrypt seedb. var encrypted = BitcoinEncryptedSecret.EncryptSeed (seedb, derived); //0x01 0x43 + flagbyte + addresshash + ownerentropy + encryptedpart1[0...7] + encryptedpart2 which totals 39 bytes var bytes = new[] { flagByte } .Concat(addresshash) .Concat(this.OwnerEntropy) .Concat(encrypted.Take(8).ToArray()) .Concat(encrypted.Skip(16).ToArray()) .ToArray(); var encryptedSecret = new BitcoinEncryptedSecretEC(bytes, Network); return new EncryptedKeyResult(encryptedSecret, generatedaddress, seedb, () => { //ECMultiply factorb by G, call the result pointb. The result is 33 bytes. var pointb = new Key(factorb).PubKey.ToBytes(); //The first byte is 0x02 or 0x03. XOR it by (derivedhalf2[31] & 0x01), call the resulting byte pointbprefix. var pointbprefix = (byte)(pointb[0] ^ (byte)(derived[63] & 0x01)); var pointbx = BitcoinEncryptedSecret.EncryptKey(pointb.Skip(1).ToArray(), derived); var encryptedpointb = new byte[] { pointbprefix }.Concat(pointbx).ToArray(); var confirmBytes = Network.GetVersionBytes(Base58Type.CONFIRMATION_CODE) .Concat(new[] { flagByte }) .Concat(addresshash) .Concat(OwnerEntropy) .Concat(encryptedpointb) .ToArray(); return new BitcoinConfirmationCode(Encoders.Base58Check.EncodeData(confirmBytes), Network); }); }
public bool IsFrom(PubKey pubKey) { var template = new PayToPubkeyHashTemplate(); var result = template.ExtractScriptSigParameters(ScriptSig); return result != null && result.PublicKey == pubKey; }
public Script GenerateScriptPubKey(PubKey pubkey) { return(GenerateScriptPubKey(pubkey.ToBytes(true))); }
public static Script PayToPubkey(PubKey pubkey) { return PayToPubkeyTemplate.Instance.GenerateScriptPubKey(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 Script GenerateScriptPubKey(PubKey pubkey) { return new Script( Op.GetPushOp(pubkey.ToBytes()), OpcodeType.OP_CHECKSIG ); }
public WitScript GenerateWitScript(TransactionSignature signature, PubKey publicKey) { if(publicKey == null) throw new ArgumentNullException("publicKey"); return new WitScript( signature == null ? OpcodeType.OP_0 : Op.GetPushOp(signature.ToBytes()), Op.GetPushOp(publicKey.ToBytes()) ); }
protected override BitcoinBlindedAddress CreateBlindedAddressCore(PubKey blinded) { return(this); }