public void TestCreateCoinbaseAndSpend()
{
var txManager = new TransactionManager();
var keyPair = txManager.CreateKeyPair();
var privateKey = keyPair.Item1;
var publicKey = keyPair.Item2;
var coinbaseTx = txManager.CreateCoinbaseTransaction(publicKey, Encoding.ASCII.GetBytes("coinbase text!")).Transaction;
var publicKeyScript = txManager.CreatePublicKeyScript(publicKey);
var privateKeyScript = txManager.CreatePrivateKeyScript(coinbaseTx, 0, (byte)ScriptHashType.SIGHASH_ALL, privateKey, publicKey);
var script = privateKeyScript.Concat(publicKeyScript);
var scriptEngine = new ScriptEngine();
Assert.IsTrue(scriptEngine.VerifyScript(UInt256.Zero, 0, publicKeyScript.ToArray(), coinbaseTx, 0, script));
}
public byte[] CreatePrivateKeyScript(Transaction tx, int inputIndex, byte hashType, ECPrivateKeyParameters privateKey, ECPublicKeyParameters publicKey)
{
//TODO
var scriptEngine = new ScriptEngine();
var publicAddress = CreatePublicAddress(publicKey);
var publicKeyScript = CreatePublicKeyScript(publicAddress);
var txSignature = scriptEngine.TxSignature(publicKeyScript, tx, inputIndex, hashType);
var txSignatureHash = SHA256Static.ComputeDoubleHash(txSignature);
//Debug.WriteLine("Signing Tx: {0}".Format2(txSignature.ToHexDataString()));
//Debug.WriteLine("Signing Tx Hash: {0}".Format2(txSignatureHash.ToHexDataString()));
var signer = new ECDsaSigner();
signer.Init(forSigning: true, parameters: privateKey);
var signature = signer.GenerateSignature(txSignatureHash);
var r = signature[0];
var s = signature[1];
byte[] sigEncoded;
using (var stream = new MemoryStream())
{
using (var asn1Stream = new Asn1OutputStream(stream))
{
asn1Stream.WriteObject(new DerSequence(new DerInteger(r), new DerInteger(s)));
}
sigEncoded = stream.ToArray().Concat(hashType);
}
//Debug.WriteLine("Sig R: {0}".Format2(r.ToHexNumberStringUnsigned()));
//Debug.WriteLine("Sig S: {0}".Format2(s.ToHexNumberStringUnsigned()));
//Debug.WriteLine("Sig Encoded: {0}".Format2(sigEncoded.ToHexDataString()));
using (var privateKeyScript = new ScriptBuilder())
{
privateKeyScript.WritePushData(sigEncoded);
privateKeyScript.WritePushData(publicAddress);
//Debug.WriteLine("Private Script: {0}".Format2(privateKeyScript.GetScript().ToHexDataString()));
return privateKeyScript.GetScript();
}
}
private void TestTransactionVerifySignature(byte[] expectedHashTypes, byte[][] expectedSignatures, byte[][] expectedSignatureHashes, Transaction tx, IDictionary<UInt256, Transaction> txLookup)
{
var scriptEngine = new ScriptEngine();
for (var inputIndex = 0; inputIndex < tx.Inputs.Length; inputIndex++)
{
var input = tx.Inputs[inputIndex];
var prevOutput = txLookup[input.PreviousTxOutputKey.TxHash].Outputs[input.PreviousTxOutputKey.TxOutputIndex.ToIntChecked()];
var scriptSigBytes = input.ScriptSignature.ToArray();
var hashType = GetHashTypeFromScriptSig(scriptSigBytes);
var sig = GetSigFromScriptSig(scriptSigBytes);
var pubKey = GetPubKeyFromScripts(scriptSigBytes, prevOutput.ScriptPublicKey.ToArray());
byte[] txSignature, txSignatureHash;
var result = scriptEngine.VerifySignature(prevOutput.ScriptPublicKey.ToArray(), tx, sig.ToArray(), pubKey.ToArray(), inputIndex, out hashType, out txSignature, out txSignatureHash);
Assert.AreEqual(expectedHashTypes[inputIndex], hashType);
CollectionAssert.AreEqual(expectedSignatures[inputIndex].ToList(), txSignature.ToList());
CollectionAssert.AreEqual(expectedSignatureHashes[inputIndex].ToList(), txSignatureHash.ToList());
Assert.IsTrue(result);
}
}
private void TestTransactionVerifyScript(Transaction tx, IDictionary<UInt256, Transaction> txLookup)
{
var scriptEngine = new ScriptEngine();
for (var inputIndex = 0; inputIndex < tx.Inputs.Length; inputIndex++)
{
var input = tx.Inputs[inputIndex];
var prevOutput = txLookup[input.PreviousTxOutputKey.TxHash].Outputs[input.PreviousTxOutputKey.TxOutputIndex.ToIntChecked()];
var script = GetScriptFromInputPrevOutput(input, prevOutput);
var result = scriptEngine.VerifyScript(UInt256.Zero /*blockHash*/, -1 /*txIndex*/, prevOutput.ScriptPublicKey.ToArray(), tx, inputIndex, script);
Assert.IsTrue(result);
}
}
private void TestTransactionSignature(byte[][] expectedSignatures, Transaction tx, IDictionary<UInt256, Transaction> txLookup)
{
var scriptEngine = new ScriptEngine();
for (var inputIndex = 0; inputIndex < tx.Inputs.Length; inputIndex++)
{
var input = tx.Inputs[inputIndex];
var prevOutput = txLookup[input.PreviousTxOutputKey.TxHash].Outputs[input.PreviousTxOutputKey.TxOutputIndex.ToIntChecked()];
var hashType = GetHashTypeFromScriptSig(input.ScriptSignature.ToArray());
var actual = scriptEngine.TxSignature(prevOutput.ScriptPublicKey.ToArray(), tx, inputIndex, hashType);
CollectionAssert.AreEqual(expectedSignatures[inputIndex].ToList(), actual.ToList());
}
}
public virtual void ValidationTransactionScript(ChainedHeader chainedHeader, Transaction tx, int txIndex, TxInput txInput, int txInputIndex, TxOutput prevTxOutput)
{
var scriptEngine = new ScriptEngine(this.IgnoreSignatures);
// create the transaction script from the input and output
var script = txInput.ScriptSignature.Concat(prevTxOutput.ScriptPublicKey);
if (!scriptEngine.VerifyScript(chainedHeader.Hash, txIndex, prevTxOutput.ScriptPublicKey.ToArray(), tx, txInputIndex, script.ToArray()))
{
logger.Debug($"Script did not pass in block: {chainedHeader.Hash}, tx: {txIndex}, {tx.Hash}, input: {txInputIndex}");
throw new ValidationException(chainedHeader.Hash);
}
}