/// <summary>
/// Calculates the sum of the outputs that are sending coins to a key in the wallet. The flag controls whether to
/// include spent outputs or not.
/// </summary>
internal ulong GetValueSentToMe(Wallet wallet, bool includeSpent)
{
// This is tested in WalletTest.
var v = 0UL;
foreach (var o in _outputs)
{
if (!o.IsMine(wallet)) continue;
if (!includeSpent && !o.IsAvailableForSpending) continue;
v += o.Value;
}
return v;
}
/// <summary>
/// Once a transaction has some inputs and outputs added, the signatures in the inputs can be calculated. The
/// signature is over the transaction itself, to prove the redeemer actually created that transaction,
/// so we have to do this step last.
/// </summary>
/// <remarks>
/// This method is similar to SignatureHash in script.cpp
/// </remarks>
/// <param name="hashType">This should always be set to SigHash.ALL currently. Other types are unused. </param>
/// <param name="wallet">A wallet is required to fetch the keys needed for signing.</param>
/// <exception cref="ScriptException"/>
public void SignInputs(SigHash hashType, Wallet wallet)
{
Debug.Assert(_inputs.Count > 0);
Debug.Assert(_outputs.Count > 0);
// I don't currently have an easy way to test other modes work, as the official client does not use them.
Debug.Assert(hashType == SigHash.All);
// The transaction is signed with the input scripts empty except for the input we are signing. In the case
// where addInput has been used to set up a new transaction, they are already all empty. The input being signed
// has to have the connected OUTPUT program in it when the hash is calculated!
//
// Note that each input may be claiming an output sent to a different key. So we have to look at the outputs
// to figure out which key to sign with.
var signatures = new byte[_inputs.Count][];
var signingKeys = new EcKey[_inputs.Count];
for (var i = 0; i < _inputs.Count; i++)
{
var input = _inputs[i];
Debug.Assert(input.ScriptBytes.Length == 0, "Attempting to sign a non-fresh transaction");
// Set the input to the script of its output.
input.ScriptBytes = input.Outpoint.ConnectedPubKeyScript;
// Find the signing key we'll need to use.
var connectedPubKeyHash = input.Outpoint.ConnectedPubKeyHash;
var key = wallet.FindKeyFromPubHash(connectedPubKeyHash);
// This assert should never fire. If it does, it means the wallet is inconsistent.
Debug.Assert(key != null, "Transaction exists in wallet that we cannot redeem: " + Utils.BytesToHexString(connectedPubKeyHash));
// Keep the key around for the script creation step below.
signingKeys[i] = key;
// The anyoneCanPay feature isn't used at the moment.
const bool anyoneCanPay = false;
var hash = HashTransactionForSignature(hashType, anyoneCanPay);
// Set the script to empty again for the next input.
input.ScriptBytes = TransactionInput.EmptyArray;
// Now sign for the output so we can redeem it. We use the keypair to sign the hash,
// and then put the resulting signature in the script along with the public key (below).
using (var bos = new MemoryStream())
{
bos.Write(key.Sign(hash));
bos.Write((byte) (((int) hashType + 1) | (anyoneCanPay ? 0x80 : 0)));
signatures[i] = bos.ToArray();
}
}
// Now we have calculated each signature, go through and create the scripts. Reminder: the script consists of
// a signature (over a hash of the transaction) and the complete public key needed to sign for the connected
// output.
for (var i = 0; i < _inputs.Count; i++)
{
var input = _inputs[i];
Debug.Assert(input.ScriptBytes.Length == 0);
var key = signingKeys[i];
input.ScriptBytes = Script.CreateInputScript(signatures[i], key.PubKey);
}
// Every input is now complete.
}
/// <summary>
/// Calculates the sum of the outputs that are sending coins to a key in the wallet.
/// </summary>
public ulong GetValueSentToMe(Wallet wallet)
{
return GetValueSentToMe(wallet, true);
}
/// <summary>
/// Calculates the sum of the inputs that are spending coins with keys in the wallet. This requires the
/// transactions sending coins to those keys to be in the wallet. This method will not attempt to download the
/// blocks containing the input transactions if the key is in the wallet but the transactions are not.
/// </summary>
/// <returns>Sum in nanocoins.</returns>
/// <exception cref="ScriptException"/>
public ulong GetValueSentFromMe(Wallet wallet)
{
// This is tested in WalletTest.
var v = 0UL;
foreach (var input in _inputs)
{
// This input is taking value from an transaction in our wallet. To discover the value,
// we must find the connected transaction.
var connected = input.GetConnectedOutput(wallet.Unspent);
if (connected == null)
connected = input.GetConnectedOutput(wallet.Spent);
if (connected == null)
connected = input.GetConnectedOutput(wallet.Pending);
if (connected == null)
continue;
// The connected output may be the change to the sender of a previous input sent to this wallet. In this
// case we ignore it.
if (!connected.IsMine(wallet))
continue;
v += connected.Value;
}
return v;
}
/// <summary>
/// Constructs a BlockChain connected to the given wallet and store. To obtain a <see cref="Wallet"/> you can construct
/// one from scratch, or you can deserialize a saved wallet from disk using <see cref="Wallet.LoadFromFile"/>.
/// </summary>
/// <remarks>
/// For the store you can use a <see cref="MemoryBlockStore"/> if you don't care about saving the downloaded data, or a
/// <see cref="BoundedOverheadBlockStore"/> if you'd like to ensure fast start-up the next time you run the program.
/// </remarks>
/// <exception cref="BlockStoreException"/>
public BlockChain(NetworkParameters @params, Wallet wallet, IBlockStore blockStore)
: this(@params, new List<Wallet>(), blockStore)
{
if (wallet != null)
AddWallet(wallet);
}
/// <summary>
/// Add a wallet to the BlockChain. Note that the wallet will be unaffected by any blocks received while it
/// was not part of this BlockChain. This method is useful if the wallet has just been created, and its keys
/// have never been in use, or if the wallet has been loaded along with the BlockChain
/// </summary>
public void AddWallet(Wallet wallet)
{
lock (this)
{
_wallets.Add(wallet);
}
}