Understand how minors create several outings in a Coinbase transaction
In Bitcoin, the role of a minor is to create new blocks and validate transactions on the blockchain. However, when it comes to creating several outings in a single transaction (as in a Coinbase transaction), minors must be creative. In this article, we will explore how minors achieve this feat.
The problem: an outing
Depending on the specification of Bitcoin Core for Coinbase transactions, each output is coded in hard at the Vout ‘index of 1.
Minor solution: Source code
A more in -depth examination of the Bitcoin source code reveals that minors have developed an intelligent solution to create several outings in a Coinbase transaction. In src / node / mininer.cpp, we find:
C
Cbitcoin :: Cbitcoin () {
// ...
Cmutabletransaction * Coinbasetx = new cmutabletransaction ();
// Create a cornerbase transaction.
Cbitcoin_public static constant std :: map coinbasetransactions;
For (size_t i = 1; i <= 1000; ++ i) {
Uint256 address;
If (! Coinbasetx-> getfromaddress ()) {
Address = I;
} other {
// If a transaction has already been generated, reuse it
If (Std :: Find (Coinbasetransactions.begin (), Coinbasetransacts.end (),
Std :: make_pair (address, 0))! = Coinbasetransactions.end ()) {
// Reuse the existing transaction
I = Coinbasetransactions [Address] [1];
} other {
// Generate a new transaction and store it in Coinbasetransactions
Coinbasetx-> Settoaddress (i);
If (I == 1000) Break; // Stop generating transactions once we have reached the output limit
Std :: Map transactions = {
{"tx", i},
{"Vout", i}
};
Coinbasetransactions [address] = transactions;
}
}
// Create a new outing with the desired number of votes
Cbitcoinoutput * output = new cbitcoinoutput ();
Std :: Map spertins = {
{"Vout", i}
};
Output-> setname ("output");
exit-> setid (i);
Output-> setvalue (i);
// Add the transaction to the Coinbase transaction
CbitiTransAction * tx = new cbitointransAction ();
TX-> AddtransAction (Coinbasetx, 0, 10000); // Add all outputs to the transaction
If (I == 1000) Break; // Stop generating transactions once we have reached the output limit
Output-> settransaction (TX);
Coinbasetx-> Addoutput (outing);
Delete TX;
Remove the output;
Coinbasetransactions [Address] = STD :: Move (outings);
}
Coinbasetx return;
}
'
What's going on here?
In this code, the minor creates an objectCbitCointransAction ‘and adds it to the” Coinbase transaction “. They then add all the outputs of this transaction to the Coinbase transaction using their own personalized output creation function (“Cbitcoinoutput”). This allows them to create several outings in a single transaction.
The minor also stores these outings in a card, where each key is an address and value is another card containing the number of outings for this address. This allows the minor to reuse existing transactions (if applicable) during the generation of new ones.
Conclusion
In conclusion, minors have developed creative solutions to create several outings in a single transaction. Using their personalized output creation function (“Cbitcoinoutput”), they can effectively manage a large number of outings and reuse existing transactions.