twisterarmy/twister-core
1
0
Fork 0
mirror of https://github.com/twisterarmy/twister-core.git synced 2025-01-10 23:07:52 +00:00
Code Issues Projects Releases Wiki Activity

removed vin and vout from CTransaction

Browse Source 
genesis block broken
This commit is contained in:
Miguel Freitas 2013-07-15 20:14:57 -03:00
parent 2bdd876dfa
commit 73e1f33dc8
17 changed files with 238 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/bloom.cpp
View File

@ -101,7 +101,7 @@ bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx, const uint256& ha
// for finding tx when they appear in a block // for finding tx when they appear in a block
if (contains(hash)) if (contains(hash))
fFound = true; fFound = true;
/*
for (unsigned int i = 0; i < tx.vout.size(); i++) for (unsigned int i = 0; i < tx.vout.size(); i++)
{ {
const CTxOut& txout = tx.vout[i]; const CTxOut& txout = tx.vout[i];
@ -133,10 +133,10 @@ bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx, const uint256& ha
} }
} }
} }
*/
if (fFound) if (fFound)
return true; return true;
/*
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
// Match if the filter contains an outpoint tx spends // Match if the filter contains an outpoint tx spends
@ -155,6 +155,6 @@ bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx, const uint256& ha
return true; return true;
} }
} }
*/
return false; return false;
} }

113
src/chainparams.cpp
View File

@ -16,81 +16,7 @@
unsigned int pnSeed[] = unsigned int pnSeed[] =
{ {
0xe473042e, 0xb177f2ad, 0xd63f3fb2, 0xf864f736, 0x44a23ac7, 0xcf6d9650, 0xd648042e, 0x0536f447, 0x0300a8c0 // 192.168.0.3 (default port)
0x3c654ed0, 0x3e16a5bc, 0xa38e09b0, 0xdfae795b, 0xabfeca5b, 0x94ad7840, 0xf3b9f1c7, 0xbe70e0ad,
0x3bbd09b0, 0x8d0c7dd5, 0x3b2a7332, 0x1a06175e, 0x581f175e, 0xca0d2dcc, 0x0fdbc658, 0xcf591ec7,
0x295a12b2, 0xb4707bce, 0x68bb09b0, 0x4e735747, 0x89709553, 0x05a7814e, 0x5b8ec658, 0x402c5512,
0xe80d0905, 0x17681a5e, 0xc02aa748, 0x9f811741, 0x5f321cb0, 0x23e1ee47, 0xaf7f170c, 0xaa240ab0,
0xedea6257, 0x76106bc1, 0x2cf310cc, 0x08612acb, 0x9c682e4e, 0x8e963c6c, 0x443c795b, 0x22e246b8,
0xfa1f2dcc, 0x90118140, 0x3821042e, 0x33c3fd2e, 0x10046d5b, 0x40d14b3e, 0x7fb8f8ce, 0x67696550,
0xeeecbe58, 0x4f341745, 0x46b8fbd5, 0xc8463932, 0x6b73e862, 0x4c715932, 0x4a6785d5, 0xce3a64c2,
0xde9604c7, 0x9b06884f, 0x18002a45, 0xea9bc345, 0xc4f1c658, 0xe475c1c7, 0xdd3e795b, 0x9722175e,
0x34562f4e, 0x66c46e4e, 0x40bb1243, 0x7d9171d0, 0x17b8dbd5, 0x63cbfd2e, 0x1a08b8d8, 0x6175a73b,
0x228d2660, 0x8627c658, 0x9c566644, 0x38cca5bc, 0x3089de5b, 0x92e25f5d, 0xa393f73f, 0xcc92dc3e,
0x27487446, 0x62cbfd2e, 0x9d983b45, 0xf72a09b0, 0xf75f042e, 0x6434bb6a, 0xb29e77d8, 0x19be4fd9,
0x76443243, 0x9dd72645, 0x694cef43, 0x89c2efd5, 0x5f1c5058, 0x46c6e45b, 0xe1391b40, 0x77ccefd5,
0x472e5a6d, 0x85709553, 0xdd4f5d4c, 0x64ef5a46, 0x7f0ae502, 0xcf08d850, 0x3460042e, 0xeafa2d42,
0x793c9044, 0x9d094746, 0x1ab9b153, 0xbfe9a5bc, 0x34771fb0, 0xb7722e32, 0x1168964b, 0x19b06ab8,
0x19243b25, 0x13188045, 0xb4070905, 0x728ebb5d, 0x44f24ac8, 0xa317fead, 0x642f6a57, 0x3d951f32,
0x3d312e4e, 0xfac4d048, 0xefc4dd50, 0x52b9f1c7, 0xc14d3cc3, 0x0219ea44, 0x3b79d058, 0xfa217242,
0x39c80647, 0xfb697252, 0x1d495a42, 0x0aa81f4e, 0x58249ab8, 0xe6a8e6c3, 0x2bc4dad8, 0x85963c6c,
0xa4ce09b0, 0x2005f536, 0x5cc2703e, 0x1992de43, 0x74e86b4c, 0xe7085653, 0xf5e15a51, 0xb4872b60,
0x29e2b162, 0xa07ea053, 0x8229fd18, 0x4562ec4d, 0x8dec814e, 0x36cfa4cf, 0x96461032, 0x3c8770de,
0xd10a1f5f, 0x95934641, 0x97cd65d0, 0x2e35324a, 0x2566ba1f, 0x1ca1a9d1, 0xb808b8d5, 0xf9a24a5d,
0xafc8d431, 0xe4b8d9b2, 0x0f5321b2, 0x330bc658, 0x74b347ce, 0x972babd5, 0x044f7d4f, 0x06562f4e,
0x8b8d3c6c, 0x3507c658, 0xe4174e4d, 0xf1c009b0, 0x52249ab8, 0x27211772, 0xf6a9ba59, 0x7a391b40,
0x855dc6c0, 0x291f20b2, 0xe29bc345, 0x90963c6c, 0x0af70732, 0x4242a91f, 0x4c531d48, 0xa32df948,
0x627e3044, 0x65be1f54, 0x1a0cbf83, 0x6a443532, 0x8d5f1955, 0xbafa8132, 0x3534bdd5, 0xca019dd9,
0x8a0d9332, 0x5584e7d8, 0x7cd1f25e, 0xeabe3fb2, 0x2945d0d1, 0x46415718, 0x70d6042e, 0x99eb76d0,
0x9ece09b0, 0xb3777418, 0x5e5e91d9, 0x237a3ab0, 0xf512b62e, 0x45dec347, 0x59b7f862, 0x4c443b25,
0x3cc6484b, 0x9a8ec6d1, 0x021eea44, 0xc9483944, 0xfd567e32, 0xfd204bb2, 0xc5330bcc, 0x5202894e,
0xf9e309b0, 0x4cc17557, 0xdb9064ae, 0xe19e77d8, 0x25857f60, 0xeb4a15ad, 0x1f47f554, 0xea4472d9,
0xd20de593, 0xf5733b25, 0x11892b54, 0x5729d35f, 0xe6188cd1, 0x488b132e, 0x541c534a, 0xa8e854ae,
0xa255a66c, 0x33688763, 0xc6629ac6, 0xc20a6265, 0xcd92a059, 0x72029d3b, 0x4c298f5e, 0x51452e4e,
0xbb065058, 0x15fd2dcc, 0xf40c135e, 0x615a0bad, 0x0c6a6805, 0x4971a7ad, 0x17f2a5d5, 0xf8babf47,
0xb61f50ad, 0x4e1451b1, 0xf72d9252, 0x5c2abe58, 0xbd987c61, 0x084ae5cf, 0x20781fb0, 0x38b0f160,
0x18aac705, 0x14f86dc1, 0x5556f481, 0x0a36c144, 0xeb446e4c, 0x2c1c0d6c, 0xbd0ff860, 0x869f92db,
0x36c94f4c, 0x05502444, 0x148fe55b, 0xd5301e59, 0xd57a8f45, 0x110dc04a, 0x8670fc36, 0xee733b25,
0xca56f481, 0x2a5c3bae, 0x844b0905, 0x1e51fe53, 0x0241c244, 0x59c0614e, 0x94e70a55, 0x7312fead,
0xb735be44, 0xa55d0905, 0x2f63962e, 0x14a4e15b, 0x63f8f05c, 0x62d0d262, 0x3cab41ad, 0x87f1b1cb,
0x018da6b8, 0xb3967dd5, 0xcb56f481, 0x685ad718, 0x3b4aeeca, 0x8d106bc1, 0x51180905, 0x72660f48,
0x1521a243, 0x5b56f481, 0x6390e560, 0xdd61464e, 0x58353b25, 0x553fc062, 0x27c45d59, 0xacc62e4e,
0x0d5a1cd9, 0x7f65f442, 0xbdeef660, 0xf1bd1855, 0xf8473cae, 0x13b120b2, 0x442440d0, 0x53fd4352,
0xa305fc57, 0x458be84d, 0x639ce1c3, 0xebaaee47, 0x95e2c247, 0xf056f481, 0x6256f481, 0x1d87c65e,
0x0a453418, 0x5beb175e, 0xd64f1618, 0xc360795b, 0x2fbf5753, 0xa8c58e53, 0x651cec52, 0x9d37b043,
0x124a9758, 0x5242e4a9, 0x89913c6c, 0x880efe2e, 0x2f2f2f0c, 0x72b26751, 0x2896e46d, 0x80f4166c,
0x320d59ad, 0xc50151d0, 0x11a8aa43, 0xccf56057, 0x5fbad118, 0x4719b151, 0x2b5f4bc0, 0x4d7a4a50,
0xad06e047, 0x62ef5a46, 0x5aebde58, 0xdf7aa66c, 0x851acb50, 0x66b9a559, 0x3e9bb153, 0xcc512f2e,
0xc073b08e, 0xd519be58, 0xe981ea4d, 0x12fd50cb, 0x378739ad, 0x06683cae, 0xa22310b2, 0xc185c705,
0x8741b545, 0xa26c8318, 0x22d5bc43, 0x39201ec0, 0x68581e3e, 0xdc9bcf62, 0xd508cc82, 0xb149675b,
0x4c9609b0, 0x84feb84c, 0x08291e2e, 0xfd2253b2, 0x1fd269c1, 0xc9483932, 0x4d641fb0, 0x7d37c918,
0xa9de20ad, 0x77e2d655, 0x6d421b59, 0xd7668f80, 0xced09b62, 0xa9e5a5bc, 0xa4074e18, 0x60fc5ecc,
0x01300148, 0x68062444, 0xb4224847, 0xed3aa443, 0xb772fb43, 0x9f56f481, 0x220dfd18, 0x8e1c3d6c,
0xc44f09b0, 0x7df2bb73, 0xe22fb844, 0xea534242, 0xb6a755d4, 0xa036654b, 0x138ece5b, 0xda65d3c3,
0x955871bc, 0x792124b0, 0xfc82594c, 0x851d494b, 0x2c7aee47, 0x26af46b8, 0x1416252e, 0xa8abb944,
0x36c49d25, 0x674f645d, 0x363646b8, 0x9e1a2942, 0x66d0c154, 0xc6c2a545, 0x3570f2ad, 0xe7d547c7,
0x7d104932, 0x18cb9c18, 0x1dcfa4cf, 0xd156f481, 0x2a02b91f, 0x3eeb3fa8, 0xcac4175e, 0x34146d42,
0x994c4d46, 0x5666f440, 0x85d6713e, 0x5ecb296c, 0x0ea0ae46, 0x87e69f42, 0xc58409b0, 0x1f3436ae,
0x21dc6a57, 0x4ad1cd42, 0xfb8c1a4c, 0x52d3dab2, 0x3769894b, 0xb52f1c62, 0x3677916d, 0x82b3fe57,
0x493d4ac6, 0x9f963c6c, 0x5d91ff60, 0x458e0dad, 0xa49d0947, 0x491a3e18, 0x4aadcd5b, 0x0e46494b,
0x1d1610ad, 0x1a10af5d, 0x4956f481, 0x207a3eae, 0x77e73244, 0xfa3b8742, 0x3261fc36, 0xfcebf536,
0x1662e836, 0xf655f636, 0xa2dbd0ad, 0x23036693, 0x30448432, 0xa2b03463, 0x30730344, 0x8e4a6882,
0x0c50a1cb, 0xc8d8c06b, 0xc9cd6191, 0xf443db50, 0xa9553c50, 0x23145847, 0xc35da66c, 0x29c12a60,
0x55c2b447, 0x7434f75c, 0x61660640, 0xde2a7018, 0xc639494c, 0x1c306fce, 0x19b89244, 0xd29a6462,
0x462cd1b2, 0x29902f44, 0x2817fa53, 0x21a30905, 0x7777ae46, 0x288443a1, 0x7bee5148, 0xc2a8b043,
0xf5c3d35f, 0x2311ef84, 0x57de08a4, 0x6b221bb2, 0xf2625846, 0x4b9e09b0, 0xa24f880e, 0x22b11447,
0xb3a0c744, 0x919e77d8, 0xec8b64ae, 0xff5c8d45, 0x7b15b484, 0x32679a5f, 0xba80b62e, 0x05c25c61,
0x60014746, 0x5e8fb04c, 0xe67c0905, 0x4329c658, 0xac8fe555, 0xf875e647, 0x67406386, 0x35ceea18,
0xbb79484b, 0xd7b9fa62, 0x238209b0, 0x208a1d32, 0x9630995e, 0x039c1318, 0x6e48006c, 0x60582344,
0xadbb0150, 0x853fd462, 0x03772e4e, 0x652ce960, 0x49b630ad, 0x9993af43, 0x3735b34b, 0x548a07d9,
0x55a44aad, 0xa23d1bcc, 0xfdbb2f4e, 0x530b24a0, 0x0a44b451, 0x6827c657, 0x1f66494b, 0x4e680a47,
0x77e7b747, 0xa5eb3fa8, 0x6649764a, 0xd4e76c4b, 0x2c691fb0, 0xf1292e44, 0xc6d6c774, 0x85d23775,
0x28275f4d, 0x259ae46d, 0x02424e81, 0x5f16be58, 0xe707c658, 0x49eae5c7, 0xd5d147ad, 0x9a7abdc3,
0xe8ac7fc7, 0x84ec3aae, 0xc24942d0, 0x294aa318, 0x08ac3d18, 0x8894042e, 0xb24609b0, 0x9bcaab58,
0xc400f712, 0xd5c512b8, 0x2c02cc62, 0x25080fd8, 0xed74a847, 0x18a5ec5e, 0x9850ec6d, 0xf8909758,
0x7f56f481, 0x4496f23c, 0xae27784f, 0xcb7cd93e, 0x06e32860, 0x50b9a84f, 0x3660434a, 0x09161f5f,
0x900486bc, 0x08055459, 0xe7ec1017, 0x7e39494c, 0x4f443b25, 0x14751a8a, 0x717d03d4, 0xbd0e24d8,
0x054b6f56, 0x854c496c, 0xd92a454a, 0xc39bd054, 0x6093614b, 0x9dbad754, 0x5bf0604a, 0x99f22305
}; };
class CMainParams : public CChainParams { class CMainParams : public CChainParams {
@ -99,13 +25,13 @@ public:
// The message start string is designed to be unlikely to occur in normal data. // The message start string is designed to be unlikely to occur in normal data.
// The characters are rarely used upper ASCII, not valid as UTF-8, and produce // The characters are rarely used upper ASCII, not valid as UTF-8, and produce
// a large 4-byte int at any alignment. // a large 4-byte int at any alignment.
pchMessageStart[0] = 0xf9; pchMessageStart[0] = 0xf0;
pchMessageStart[1] = 0xbe; pchMessageStart[1] = 0xda;
pchMessageStart[2] = 0xb4; pchMessageStart[2] = 0xbb;
pchMessageStart[3] = 0xd9; pchMessageStart[3] = 0xd2;
vAlertPubKey = ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284"); vAlertPubKey = ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284");
nDefaultPort = 8333; nDefaultPort = 28333;
nRPCPort = 8332; nRPCPort = 28332;
bnProofOfWorkLimit = CBigNum(~uint256(0) >> 32); bnProofOfWorkLimit = CBigNum(~uint256(0) >> 32);
nSubsidyHalvingInterval = 210000; nSubsidyHalvingInterval = 210000;
@ -117,13 +43,9 @@ public:
// CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73) // CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
// CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B) // CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
// vMerkleTree: 4a5e1e // vMerkleTree: 4a5e1e
const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks"; const char* pszTimestamp = "The Times 14/Jul/2013 Globo caught bribing Receita Federal employee to rob R$615M tax evasion documents.";
CTransaction txNew; CTransaction txNew;
txNew.vin.resize(1); txNew.message = CScript() << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
txNew.vout.resize(1);
txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
txNew.vout[0].nValue = 50 * COIN;
txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
genesis.vtx.push_back(txNew); genesis.vtx.push_back(txNew);
genesis.hashPrevBlock = 0; genesis.hashPrevBlock = 0;
genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.hashMerkleRoot = genesis.BuildMerkleTree();
@ -133,13 +55,10 @@ public:
genesis.nNonce = 2083236893; genesis.nNonce = 2083236893;
hashGenesisBlock = genesis.GetHash(); hashGenesisBlock = genesis.GetHash();
assert(hashGenesisBlock == uint256("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")); //assert(hashGenesisBlock == uint256("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"));
assert(genesis.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b")); //assert(genesis.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
vSeeds.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be")); //vSeeds.push_back(CDNSSeedData("bitcoin.sipa.be", "seed.bitcoin.sipa.be"));
vSeeds.push_back(CDNSSeedData("bluematt.me", "dnsseed.bluematt.me"));
vSeeds.push_back(CDNSSeedData("dashjr.org", "dnsseed.bitcoin.dashjr.org"));
vSeeds.push_back(CDNSSeedData("xf2.org", "bitseed.xf2.org"));
base58Prefixes[PUBKEY_ADDRESS] = 0; base58Prefixes[PUBKEY_ADDRESS] = 0;
base58Prefixes[SCRIPT_ADDRESS] = 5; base58Prefixes[SCRIPT_ADDRESS] = 5;
@ -196,12 +115,12 @@ public:
genesis.nTime = 1296688602; genesis.nTime = 1296688602;
genesis.nNonce = 414098458; genesis.nNonce = 414098458;
hashGenesisBlock = genesis.GetHash(); hashGenesisBlock = genesis.GetHash();
assert(hashGenesisBlock == uint256("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943")); //assert(hashGenesisBlock == uint256("000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"));
vFixedSeeds.clear(); vFixedSeeds.clear();
vSeeds.clear(); vSeeds.clear();
vSeeds.push_back(CDNSSeedData("bitcoin.petertodd.org", "testnet-seed.bitcoin.petertodd.org")); //vSeeds.push_back(CDNSSeedData("bitcoin.petertodd.org", "testnet-seed.bitcoin.petertodd.org"));
vSeeds.push_back(CDNSSeedData("bluematt.me", "testnet-seed.bluematt.me")); //vSeeds.push_back(CDNSSeedData("bluematt.me", "testnet-seed.bluematt.me"));
base58Prefixes[PUBKEY_ADDRESS] = 111; base58Prefixes[PUBKEY_ADDRESS] = 111;
base58Prefixes[SCRIPT_ADDRESS] = 196; base58Prefixes[SCRIPT_ADDRESS] = 196;
@ -231,7 +150,7 @@ public:
hashGenesisBlock = genesis.GetHash(); hashGenesisBlock = genesis.GetHash();
nDefaultPort = 18444; nDefaultPort = 18444;
strDataDir = "regtest"; strDataDir = "regtest";
assert(hashGenesisBlock == uint256("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206")); //assert(hashGenesisBlock == uint256("0x0f9188f13cb7b2c71f2a335e3a4fc328bf5beb436012afca590b1a11466e2206"));
vSeeds.clear(); // Regtest mode doesn't have any DNS seeds. vSeeds.clear(); // Regtest mode doesn't have any DNS seeds.

4
src/checkqueue.h
View File

@ -99,6 +99,7 @@ private:
// * Try to account for idle jobs which will instantly start helping. // * Try to account for idle jobs which will instantly start helping.
// * Don't do batches smaller than 1 (duh), or larger than nBatchSize. // * Don't do batches smaller than 1 (duh), or larger than nBatchSize.
nNow = std::max(1U, std::min(nBatchSize, (unsigned int)queue.size() / (nTotal + nIdle + 1))); nNow = std::max(1U, std::min(nBatchSize, (unsigned int)queue.size() / (nTotal + nIdle + 1)));
/* [MF]
vChecks.resize(nNow); vChecks.resize(nNow);
for (unsigned int i = 0; i < nNow; i++) { for (unsigned int i = 0; i < nNow; i++) {
// We want the lock on the mutex to be as short as possible, so swap jobs from the global // We want the lock on the mutex to be as short as possible, so swap jobs from the global
@ -106,14 +107,17 @@ private:
vChecks[i].swap(queue.back()); vChecks[i].swap(queue.back());
queue.pop_back(); queue.pop_back();
} }
*/
// Check whether we need to do work at all // Check whether we need to do work at all
fOk = fAllOk; fOk = fAllOk;
} }
// execute work // execute work
/*
BOOST_FOREACH(T &check, vChecks) BOOST_FOREACH(T &check, vChecks)
if (fOk) if (fOk)
fOk = check(); fOk = check();
vChecks.clear(); vChecks.clear();
*/
} while(true); } while(true);
} }

48
src/core.cpp
View File

@ -78,48 +78,18 @@ uint256 CTransaction::GetHash() const
return SerializeHash(*this); return SerializeHash(*this);
} }
bool CTransaction::IsNewerThan(const CTransaction& old) const
{
if (vin.size() != old.vin.size())
return false;
for (unsigned int i = 0; i < vin.size(); i++)
if (vin[i].prevout != old.vin[i].prevout)
return false;
bool fNewer = false;
unsigned int nLowest = std::numeric_limits<unsigned int>::max();
for (unsigned int i = 0; i < vin.size(); i++)
{
if (vin[i].nSequence != old.vin[i].nSequence)
{
if (vin[i].nSequence <= nLowest)
{
fNewer = false;
nLowest = vin[i].nSequence;
}
if (old.vin[i].nSequence < nLowest)
{
fNewer = true;
nLowest = old.vin[i].nSequence;
}
}
}
return fNewer;
}
std::string CTransaction::ToString() const std::string CTransaction::ToString() const
{ {
std::string str; std::string str;
str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%"PRIszu", vout.size=%"PRIszu", nLockTime=%u)\n", str += strprintf("CTransaction(hash=%s, ver=%d, message.size=%"PRIszu", userID.size=%"PRIszu", pubKey.size=%"PRIszu")\n",
GetHash().ToString().substr(0,10).c_str(), GetHash().ToString().substr(0,10).c_str(),
nVersion, nVersion,
vin.size(), message.size(),
vout.size(), userID.size(),
nLockTime); pubKey.size());
for (unsigned int i = 0; i < vin.size(); i++) str += " " + message.ToString() + "\n";
str += " " + vin[i].ToString() + "\n"; str += " " + userID.ToString() + "\n";
for (unsigned int i = 0; i < vout.size(); i++) str += " " + pubKey.ToString() + "\n";
str += " " + vout[i].ToString() + "\n";
return str; return str;
} }
@ -186,6 +156,7 @@ uint64 CTxOutCompressor::DecompressAmount(uint64 x)
// each bit in the bitmask represents the availability of one output, but the // each bit in the bitmask represents the availability of one output, but the
// availabilities of the first two outputs are encoded separately // availabilities of the first two outputs are encoded separately
void CCoins::CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const { void CCoins::CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) const {
/*
unsigned int nLastUsedByte = 0; unsigned int nLastUsedByte = 0;
for (unsigned int b = 0; 2+b*8 < vout.size(); b++) { for (unsigned int b = 0; 2+b*8 < vout.size(); b++) {
bool fZero = true; bool fZero = true;
@ -201,9 +172,11 @@ void CCoins::CalcMaskSize(unsigned int &nBytes, unsigned int &nNonzeroBytes) con
} }
} }
nBytes += nLastUsedByte; nBytes += nLastUsedByte;
*/
} }
bool CCoins::Spend(const COutPoint &out, CTxInUndo &undo) { bool CCoins::Spend(const COutPoint &out, CTxInUndo &undo) {
/*
if (out.n >= vout.size()) if (out.n >= vout.size())
return false; return false;
if (vout[out.n].IsNull()) if (vout[out.n].IsNull())
@ -216,6 +189,7 @@ bool CCoins::Spend(const COutPoint &out, CTxInUndo &undo) {
undo.fCoinBase = fCoinBase; undo.fCoinBase = fCoinBase;
undo.nVersion = this->nVersion; undo.nVersion = this->nVersion;
} }
*/
return true; return true;
} }

34
src/core.h
View File

@ -182,9 +182,12 @@ public:
static int64 nMinRelayTxFee; static int64 nMinRelayTxFee;
static const int CURRENT_VERSION=1; static const int CURRENT_VERSION=1;
int nVersion; int nVersion;
std::vector<CTxIn> vin; CScript message;
std::vector<CTxOut> vout; CScript userID;
unsigned int nLockTime; CScript pubKey;
//std::vector<CTxIn> vin;
//std::vector<CTxOut> vout;
//unsigned int nLockTime;
CTransaction() CTransaction()
{ {
@ -195,22 +198,22 @@ public:
( (
READWRITE(this->nVersion); READWRITE(this->nVersion);
nVersion = this->nVersion; nVersion = this->nVersion;
READWRITE(vin); READWRITE(message);
READWRITE(vout); READWRITE(userID);
READWRITE(nLockTime); READWRITE(pubKey);
) )
void SetNull() void SetNull()
{ {
nVersion = CTransaction::CURRENT_VERSION; nVersion = CTransaction::CURRENT_VERSION;
vin.clear(); message.clear();
vout.clear(); userID.clear();
nLockTime = 0; pubKey.clear();
} }
bool IsNull() const bool IsNull() const
{ {
return (vin.empty() && vout.empty()); return (message.empty() && userID.empty() && pubKey.empty());
} }
uint256 GetHash() const; uint256 GetHash() const;
@ -218,15 +221,16 @@ public:
bool IsCoinBase() const bool IsCoinBase() const
{ {
return (vin.size() == 1 && vin[0].prevout.IsNull()); //[MF] reusing coinbase as spam string
return (!message.empty() && userID.empty() && pubKey.empty());
} }
friend bool operator==(const CTransaction& a, const CTransaction& b) friend bool operator==(const CTransaction& a, const CTransaction& b)
{ {
return (a.nVersion == b.nVersion && return (a.nVersion == b.nVersion &&
a.vin == b.vin && a.message == b.message &&
a.vout == b.vout && a.userID == b.userID &&
a.nLockTime == b.nLockTime); a.pubKey == b.pubKey);
} }
friend bool operator!=(const CTransaction& a, const CTransaction& b) friend bool operator!=(const CTransaction& a, const CTransaction& b)
@ -389,7 +393,7 @@ public:
int nVersion; int nVersion;
// construct a CCoins from a CTransaction, at a given height // construct a CCoins from a CTransaction, at a given height
CCoins(const CTransaction &tx, int nHeightIn) : fCoinBase(tx.IsCoinBase()), vout(tx.vout), nHeight(nHeightIn), nVersion(tx.nVersion) { } CCoins(const CTransaction &tx, int nHeightIn) : fCoinBase(tx.IsCoinBase()), vout(), nHeight(nHeightIn), nVersion(tx.nVersion) { }
// empty constructor // empty constructor
CCoins() : fCoinBase(false), vout(0), nHeight(0), nVersion(0) { } CCoins() : fCoinBase(false), vout(0), nHeight(0), nVersion(0) { }

90
src/main.cpp
View File

@ -54,6 +54,7 @@ int64 CTransaction::nMinTxFee = 10000; // Override with -mintxfee
/** Fees smaller than this (in satoshi) are considered zero fee (for relaying) */ /** Fees smaller than this (in satoshi) are considered zero fee (for relaying) */
int64 CTransaction::nMinRelayTxFee = 10000; int64 CTransaction::nMinRelayTxFee = 10000;
CMedianFilter<int> cPeerBlockCounts(8, 0); // Amount of blocks that other nodes claim to have CMedianFilter<int> cPeerBlockCounts(8, 0); // Amount of blocks that other nodes claim to have
map<uint256, CBlock*> mapOrphanBlocks; map<uint256, CBlock*> mapOrphanBlocks;
@ -424,9 +425,10 @@ bool AddOrphanTx(const CDataStream& vMsg)
} }
mapOrphanTransactions[hash] = pvMsg; mapOrphanTransactions[hash] = pvMsg;
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
mapOrphanTransactionsByPrev[txin.prevout.hash].insert(make_pair(hash, pvMsg)); mapOrphanTransactionsByPrev[txin.prevout.hash].insert(make_pair(hash, pvMsg));
*/
printf("stored orphan tx %s (mapsz %"PRIszu")\n", hash.ToString().c_str(), printf("stored orphan tx %s (mapsz %"PRIszu")\n", hash.ToString().c_str(),
mapOrphanTransactions.size()); mapOrphanTransactions.size());
return true; return true;
@ -439,12 +441,14 @@ void static EraseOrphanTx(uint256 hash)
const CDataStream* pvMsg = mapOrphanTransactions[hash]; const CDataStream* pvMsg = mapOrphanTransactions[hash];
CTransaction tx; CTransaction tx;
CDataStream(*pvMsg) >> tx; CDataStream(*pvMsg) >> tx;
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
mapOrphanTransactionsByPrev[txin.prevout.hash].erase(hash); mapOrphanTransactionsByPrev[txin.prevout.hash].erase(hash);
if (mapOrphanTransactionsByPrev[txin.prevout.hash].empty()) if (mapOrphanTransactionsByPrev[txin.prevout.hash].empty())
mapOrphanTransactionsByPrev.erase(txin.prevout.hash); mapOrphanTransactionsByPrev.erase(txin.prevout.hash);
} }
*/
delete pvMsg; delete pvMsg;
mapOrphanTransactions.erase(hash); mapOrphanTransactions.erase(hash);
} }
@ -493,6 +497,7 @@ bool IsStandardTx(const CTransaction& tx, string& reason)
return false; return false;
} }
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
// Biggest 'standard' txin is a 3-signature 3-of-3 CHECKMULTISIG // Biggest 'standard' txin is a 3-signature 3-of-3 CHECKMULTISIG
@ -517,12 +522,13 @@ bool IsStandardTx(const CTransaction& tx, string& reason)
return false; return false;
} }
} }
*/
return true; return true;
} }
bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64 nBlockTime) bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64 nBlockTime)
{ {
/* [MF]
// Time based nLockTime implemented in 0.1.6 // Time based nLockTime implemented in 0.1.6
if (tx.nLockTime == 0) if (tx.nLockTime == 0)
return true; return true;
@ -535,6 +541,8 @@ bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64 nBlockTime)
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
if (!txin.IsFinal()) if (!txin.IsFinal())
return false; return false;
*/
return true; return true;
} }
@ -544,12 +552,13 @@ bool IsFinalTx(const CTransaction &tx, int nBlockHeight, int64 nBlockTime)
int64 GetValueOut(const CTransaction& tx) int64 GetValueOut(const CTransaction& tx)
{ {
int64 nValueOut = 0; int64 nValueOut = 0;
/* [MF]
BOOST_FOREACH(const CTxOut& txout, tx.vout) BOOST_FOREACH(const CTxOut& txout, tx.vout)
{ {
nValueOut += txout.nValue; nValueOut += txout.nValue;
if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut)) if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
throw std::runtime_error("GetValueOut() : value out of range"); throw std::runtime_error("GetValueOut() : value out of range");
} } */
return nValueOut; return nValueOut;
} }
@ -568,7 +577,7 @@ bool AreInputsStandard(const CTransaction& tx, CCoinsViewCache& mapInputs)
{ {
if (tx.IsCoinBase()) if (tx.IsCoinBase())
return true; // Coinbases don't use vin normally return true; // Coinbases don't use vin normally
/* [MF]
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
{ {
const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]); const CTxOut& prev = mapInputs.GetOutputFor(tx.vin[i]);
@ -614,13 +623,14 @@ bool AreInputsStandard(const CTransaction& tx, CCoinsViewCache& mapInputs)
if (stack.size() != (unsigned int)nArgsExpected) if (stack.size() != (unsigned int)nArgsExpected)
return false; return false;
} }
*/
return true; return true;
} }
unsigned int GetLegacySigOpCount(const CTransaction& tx) unsigned int GetLegacySigOpCount(const CTransaction& tx)
{ {
unsigned int nSigOps = 0; unsigned int nSigOps = 0;
/*
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
nSigOps += txin.scriptSig.GetSigOpCount(false); nSigOps += txin.scriptSig.GetSigOpCount(false);
@ -629,6 +639,7 @@ unsigned int GetLegacySigOpCount(const CTransaction& tx)
{ {
nSigOps += txout.scriptPubKey.GetSigOpCount(false); nSigOps += txout.scriptPubKey.GetSigOpCount(false);
} }
*/
return nSigOps; return nSigOps;
} }
@ -638,12 +649,14 @@ unsigned int GetP2SHSigOpCount(const CTransaction& tx, CCoinsViewCache& inputs)
return 0; return 0;
unsigned int nSigOps = 0; unsigned int nSigOps = 0;
/*
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
{ {
const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]); const CTxOut &prevout = inputs.GetOutputFor(tx.vin[i]);
if (prevout.scriptPubKey.IsPayToScriptHash()) if (prevout.scriptPubKey.IsPayToScriptHash())
nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig); nSigOps += prevout.scriptPubKey.GetSigOpCount(tx.vin[i].scriptSig);
} }
*/
return nSigOps; return nSigOps;
} }
@ -702,6 +715,7 @@ int CMerkleTx::SetMerkleBranch(const CBlock* pblock)
bool CheckTransaction(const CTransaction& tx, CValidationState &state) bool CheckTransaction(const CTransaction& tx, CValidationState &state)
{ {
/* [MF]
// Basic checks that don't depend on any context // Basic checks that don't depend on any context
if (tx.vin.empty()) if (tx.vin.empty())
return state.DoS(10, error("CheckTransaction() : vin empty")); return state.DoS(10, error("CheckTransaction() : vin empty"));
@ -744,12 +758,13 @@ bool CheckTransaction(const CTransaction& tx, CValidationState &state)
if (txin.prevout.IsNull()) if (txin.prevout.IsNull())
return state.DoS(10, error("CheckTransaction() : prevout is null")); return state.DoS(10, error("CheckTransaction() : prevout is null"));
} }
*/
return true; return true;
} }
int64 GetMinFee(const CTransaction& tx, bool fAllowFree, enum GetMinFee_mode mode) int64 GetMinFee(const CTransaction& tx, bool fAllowFree, enum GetMinFee_mode mode)
{ {
/*
// Base fee is either nMinTxFee or nMinRelayTxFee // Base fee is either nMinTxFee or nMinRelayTxFee
int64 nBaseFee = (mode == GMF_RELAY) ? tx.nMinRelayTxFee : tx.nMinTxFee; int64 nBaseFee = (mode == GMF_RELAY) ? tx.nMinRelayTxFee : tx.nMinTxFee;
@ -778,6 +793,8 @@ int64 GetMinFee(const CTransaction& tx, bool fAllowFree, enum GetMinFee_mode mod
if (!MoneyRange(nMinFee)) if (!MoneyRange(nMinFee))
nMinFee = MAX_MONEY; nMinFee = MAX_MONEY;
return nMinFee; return nMinFee;
*/
return 0;
} }
void CTxMemPool::pruneSpent(const uint256 &hashTx, CCoins &coins) void CTxMemPool::pruneSpent(const uint256 &hashTx, CCoins &coins)
@ -806,9 +823,11 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
if (tx.IsCoinBase()) if (tx.IsCoinBase())
return state.DoS(100, error("CTxMemPool::accept() : coinbase as individual tx")); return state.DoS(100, error("CTxMemPool::accept() : coinbase as individual tx"));
/*
// To help v0.1.5 clients who would see it as a negative number // To help v0.1.5 clients who would see it as a negative number
if ((int64)tx.nLockTime > std::numeric_limits<int>::max()) if ((int64)tx.nLockTime > std::numeric_limits<int>::max())
return error("CTxMemPool::accept() : not accepting nLockTime beyond 2038 yet"); return error("CTxMemPool::accept() : not accepting nLockTime beyond 2038 yet");
*/
// Rather not work on nonstandard transactions (unless -testnet) // Rather not work on nonstandard transactions (unless -testnet)
string reason; string reason;
@ -826,6 +845,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
// Check for conflicts with in-memory transactions // Check for conflicts with in-memory transactions
CTransaction* ptxOld = NULL; CTransaction* ptxOld = NULL;
/* [MF]
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
{ {
COutPoint outpoint = tx.vin[i].prevout; COutPoint outpoint = tx.vin[i].prevout;
@ -851,7 +871,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
break; break;
} }
} }
*/
{ {
CCoinsView dummy; CCoinsView dummy;
CCoinsViewCache view(dummy); CCoinsViewCache view(dummy);
@ -868,6 +888,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
// do all inputs exist? // do all inputs exist?
// Note that this does not check for the presence of actual outputs (see the next check for that), // Note that this does not check for the presence of actual outputs (see the next check for that),
// only helps filling in pfMissingInputs (to determine missing vs spent). // only helps filling in pfMissingInputs (to determine missing vs spent).
/*
BOOST_FOREACH(const CTxIn txin, tx.vin) { BOOST_FOREACH(const CTxIn txin, tx.vin) {
if (!view.HaveCoins(txin.prevout.hash)) { if (!view.HaveCoins(txin.prevout.hash)) {
if (pfMissingInputs) if (pfMissingInputs)
@ -875,7 +896,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
return false; return false;
} }
} }
*/
// are the actual inputs available? // are the actual inputs available?
if (!view.HaveInputs(tx)) if (!view.HaveInputs(tx))
return state.Invalid(error("CTxMemPool::accept() : inputs already spent")); return state.Invalid(error("CTxMemPool::accept() : inputs already spent"));
@ -908,6 +929,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
// Continuously rate-limit free transactions // Continuously rate-limit free transactions
// This mitigates 'penny-flooding' -- sending thousands of free transactions just to // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
// be annoying or make others' transactions take longer to confirm. // be annoying or make others' transactions take longer to confirm.
/*
if (fLimitFree && nFees < CTransaction::nMinRelayTxFee) if (fLimitFree && nFees < CTransaction::nMinRelayTxFee)
{ {
static double dFreeCount; static double dFreeCount;
@ -927,7 +949,7 @@ bool CTxMemPool::accept(CValidationState &state, CTransaction &tx, bool fLimitFr
printf("Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize); printf("Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize);
dFreeCount += nSize; dFreeCount += nSize;
} }
*/
// Check against previous transactions // Check against previous transactions
// This is done last to help prevent CPU exhaustion denial-of-service attacks. // This is done last to help prevent CPU exhaustion denial-of-service attacks.
if (!CheckInputs(tx, state, view, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC)) if (!CheckInputs(tx, state, view, true, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC))
@ -966,8 +988,10 @@ bool CTxMemPool::addUnchecked(const uint256& hash, CTransaction &tx)
// call CTxMemPool::accept to properly check the transaction first. // call CTxMemPool::accept to properly check the transaction first.
{ {
mapTx[hash] = tx; mapTx[hash] = tx;
/* [MF]
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
mapNextTx[tx.vin[i].prevout] = CInPoint(&mapTx[hash], i); mapNextTx[tx.vin[i].prevout] = CInPoint(&mapTx[hash], i);
*/
nTransactionsUpdated++; nTransactionsUpdated++;
} }
return true; return true;
@ -983,14 +1007,18 @@ bool CTxMemPool::remove(const CTransaction &tx, bool fRecursive)
if (mapTx.count(hash)) if (mapTx.count(hash))
{ {
if (fRecursive) { if (fRecursive) {
/*
for (unsigned int i = 0; i < tx.vout.size(); i++) { for (unsigned int i = 0; i < tx.vout.size(); i++) {
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(hash, i)); std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(COutPoint(hash, i));
if (it != mapNextTx.end()) if (it != mapNextTx.end())
remove(*it->second.ptx, true); remove(*it->second.ptx, true);
} }
*/
} }
/*
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
mapNextTx.erase(txin.prevout); mapNextTx.erase(txin.prevout);
*/
mapTx.erase(hash); mapTx.erase(hash);
nTransactionsUpdated++; nTransactionsUpdated++;
} }
@ -1002,6 +1030,7 @@ bool CTxMemPool::removeConflicts(const CTransaction &tx)
{ {
// Remove transactions which depend on inputs of tx, recursively // Remove transactions which depend on inputs of tx, recursively
LOCK(cs); LOCK(cs);
/* [MF]
BOOST_FOREACH(const CTxIn &txin, tx.vin) { BOOST_FOREACH(const CTxIn &txin, tx.vin) {
std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(txin.prevout); std::map<COutPoint, CInPoint>::iterator it = mapNextTx.find(txin.prevout);
if (it != mapNextTx.end()) { if (it != mapNextTx.end()) {
@ -1010,6 +1039,7 @@ bool CTxMemPool::removeConflicts(const CTransaction &tx)
remove(txConflict, true); remove(txConflict, true);
} }
} }
*/
return true; return true;
} }
@ -1497,9 +1527,10 @@ int64 CCoinsViewCache::GetValueIn(const CTransaction& tx)
return 0; return 0;
int64 nResult = 0; int64 nResult = 0;
/* [MF]
for (unsigned int i = 0; i < tx.vin.size(); i++) for (unsigned int i = 0; i < tx.vin.size(); i++)
nResult += GetOutputFor(tx.vin[i]).nValue; nResult += GetOutputFor(tx.vin[i]).nValue;
*/
return nResult; return nResult;
} }
@ -1507,12 +1538,14 @@ void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCach
{ {
// mark inputs spent // mark inputs spent
if (!tx.IsCoinBase()) { if (!tx.IsCoinBase()) {
/* [MF]
BOOST_FOREACH(const CTxIn &txin, tx.vin) { BOOST_FOREACH(const CTxIn &txin, tx.vin) {
CCoins &coins = inputs.GetCoins(txin.prevout.hash); CCoins &coins = inputs.GetCoins(txin.prevout.hash);
CTxInUndo undo; CTxInUndo undo;
assert(coins.Spend(txin.prevout, undo)); assert(coins.Spend(txin.prevout, undo));
txundo.vprevout.push_back(undo); txundo.vprevout.push_back(undo);
} }
*/
} }
// add outputs // add outputs
@ -1522,6 +1555,7 @@ void UpdateCoins(const CTransaction& tx, CValidationState &state, CCoinsViewCach
bool CCoinsViewCache::HaveInputs(const CTransaction& tx) bool CCoinsViewCache::HaveInputs(const CTransaction& tx)
{ {
if (!tx.IsCoinBase()) { if (!tx.IsCoinBase()) {
/* [MF]
// first check whether information about the prevout hash is available // first check whether information about the prevout hash is available
for (unsigned int i = 0; i < tx.vin.size(); i++) { for (unsigned int i = 0; i < tx.vin.size(); i++) {
const COutPoint &prevout = tx.vin[i].prevout; const COutPoint &prevout = tx.vin[i].prevout;
@ -1536,26 +1570,33 @@ bool CCoinsViewCache::HaveInputs(const CTransaction& tx)
if (!coins.IsAvailable(prevout.n)) if (!coins.IsAvailable(prevout.n))
return false; return false;
} }
*/
} }
return true; return true;
} }
/* [MF]
bool CScriptCheck::operator()() const { bool CScriptCheck::operator()() const {
const CScript &scriptSig = ptxTo->vin[nIn].scriptSig; const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
if (!VerifyScript(scriptSig, scriptPubKey, *ptxTo, nIn, nFlags, nHashType)) if (!VerifyScript(scriptSig, scriptPubKey, *ptxTo, nIn, nFlags, nHashType))
return error("CScriptCheck() : %s VerifySignature failed", ptxTo->GetHash().ToString().c_str()); return error("CScriptCheck() : %s VerifySignature failed", ptxTo->GetHash().ToString().c_str());
return true; return true;
} }
*/
bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType) bool VerifySignature(const CCoins& txFrom, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType)
{ {
/* [MF]
return CScriptCheck(txFrom, txTo, nIn, flags, nHashType)(); return CScriptCheck(txFrom, txTo, nIn, flags, nHashType)();
*/
return true;
} }
bool CheckInputs(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, std::vector<CScriptCheck> *pvChecks) bool CheckInputs(const CTransaction& tx, CValidationState &state, CCoinsViewCache &inputs, bool fScriptChecks, unsigned int flags, std::vector<CScriptCheck> *pvChecks)
{ {
if (!tx.IsCoinBase()) if (!tx.IsCoinBase())
{ {
/* [MF]
if (pvChecks) if (pvChecks)
pvChecks->reserve(tx.vin.size()); pvChecks->reserve(tx.vin.size());
@ -1627,6 +1668,7 @@ bool CheckInputs(const CTransaction& tx, CValidationState &state, CCoinsViewCach
} }
} }
} }
*/
} }
return true; return true;
@ -1675,6 +1717,7 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
// restore inputs // restore inputs
if (i > 0) { // not coinbases if (i > 0) { // not coinbases
const CTxUndo &txundo = blockUndo.vtxundo[i-1]; const CTxUndo &txundo = blockUndo.vtxundo[i-1];
/*
if (txundo.vprevout.size() != tx.vin.size()) if (txundo.vprevout.size() != tx.vin.size())
return error("DisconnectBlock() : transaction and undo data inconsistent"); return error("DisconnectBlock() : transaction and undo data inconsistent");
for (unsigned int j = tx.vin.size(); j-- > 0;) { for (unsigned int j = tx.vin.size(); j-- > 0;) {
@ -1702,6 +1745,7 @@ bool DisconnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex
if (!view.SetCoins(out.hash, coins)) if (!view.SetCoins(out.hash, coins))
return error("DisconnectBlock() : cannot restore coin inputs"); return error("DisconnectBlock() : cannot restore coin inputs");
} }
*/
} }
} }
@ -1811,7 +1855,7 @@ bool ConnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, C
for (unsigned int i = 0; i < block.vtx.size(); i++) for (unsigned int i = 0; i < block.vtx.size(); i++)
{ {
const CTransaction &tx = block.vtx[i]; const CTransaction &tx = block.vtx[i];
/* [MF]
nInputs += tx.vin.size(); nInputs += tx.vin.size();
nSigOps += GetLegacySigOpCount(tx); nSigOps += GetLegacySigOpCount(tx);
if (nSigOps > MAX_BLOCK_SIGOPS) if (nSigOps > MAX_BLOCK_SIGOPS)
@ -1839,7 +1883,7 @@ bool ConnectBlock(CBlock& block, CValidationState& state, CBlockIndex* pindex, C
return false; return false;
control.Add(vChecks); control.Add(vChecks);
} }
*/
CTxUndo txundo; CTxUndo txundo;
UpdateCoins(tx, state, view, txundo, pindex->nHeight, block.GetTxHash(i)); UpdateCoins(tx, state, view, txundo, pindex->nHeight, block.GetTxHash(i));
if (!tx.IsCoinBase()) if (!tx.IsCoinBase())
@ -2328,8 +2372,10 @@ bool AcceptBlock(CBlock& block, CValidationState& state, CDiskBlockPos* dbp)
(TestNet() && CBlockIndex::IsSuperMajority(2, pindexPrev, 51, 100))) (TestNet() && CBlockIndex::IsSuperMajority(2, pindexPrev, 51, 100)))
{ {
CScript expect = CScript() << nHeight; CScript expect = CScript() << nHeight;
/* [MF]
if (!std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin())) if (!std::equal(expect.begin(), expect.end(), block.vtx[0].vin[0].scriptSig.begin()))
return state.DoS(100, error("AcceptBlock() : block height mismatch in coinbase")); return state.DoS(100, error("AcceptBlock() : block height mismatch in coinbase"));
*/
} }
} }
} }
@ -4270,13 +4316,18 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
// Create coinbase tx // Create coinbase tx
CTransaction txNew; CTransaction txNew;
/* [MF]
txNew.vin.resize(1); txNew.vin.resize(1);
txNew.vin[0].prevout.SetNull(); txNew.vin[0].prevout.SetNull();
txNew.vout.resize(1); txNew.vout.resize(1);
*/
txNew.message.clear();
/* [MF] Check! add spam */
CPubKey pubkey; CPubKey pubkey;
if (!reservekey.GetReservedKey(pubkey)) if (!reservekey.GetReservedKey(pubkey))
return NULL; return NULL;
txNew.vout[0].scriptPubKey << pubkey << OP_CHECKSIG; txNew.pubKey << pubkey << OP_CHECKSIG;
// Add our coinbase tx as first transaction // Add our coinbase tx as first transaction
pblock->vtx.push_back(txNew); pblock->vtx.push_back(txNew);
@ -4323,6 +4374,7 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
double dPriority = 0; double dPriority = 0;
int64 nTotalIn = 0; int64 nTotalIn = 0;
bool fMissingInputs = false; bool fMissingInputs = false;
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
// Read prev transaction // Read prev transaction
@ -4362,6 +4414,7 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
dPriority += (double)nValueIn * nConf; dPriority += (double)nValueIn * nConf;
} }
*/
if (fMissingInputs) continue; if (fMissingInputs) continue;
// Priority is sum(valuein * age) / txsize // Priority is sum(valuein * age) / txsize
@ -4412,7 +4465,7 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
continue; continue;
// Skip free transactions if we're past the minimum block size: // Skip free transactions if we're past the minimum block size:
if (fSortedByFee && (dFeePerKb < CTransaction::nMinTxFee) && (nBlockSize + nTxSize >= nBlockMinSize)) if (fSortedByFee && (nBlockSize + nTxSize >= nBlockMinSize))
continue; continue;
// Prioritize by fee once past the priority size or we run out of high-priority // Prioritize by fee once past the priority size or we run out of high-priority
@ -4479,7 +4532,9 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
nLastBlockSize = nBlockSize; nLastBlockSize = nBlockSize;
printf("CreateNewBlock(): total size %"PRI64u"\n", nBlockSize); printf("CreateNewBlock(): total size %"PRI64u"\n", nBlockSize);
/* [MF]
pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees); pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees);
*/
pblocktemplate->vTxFees[0] = -nFees; pblocktemplate->vTxFees[0] = -nFees;
// Fill in header // Fill in header
@ -4487,7 +4542,9 @@ CBlockTemplate* CreateNewBlock(CReserveKey& reservekey)
UpdateTime(*pblock, pindexPrev); UpdateTime(*pblock, pindexPrev);
pblock->nBits = GetNextWorkRequired(pindexPrev, pblock); pblock->nBits = GetNextWorkRequired(pindexPrev, pblock);
pblock->nNonce = 0; pblock->nNonce = 0;
/* [MF]
pblock->vtx[0].vin[0].scriptSig = CScript() << OP_0 << OP_0; pblock->vtx[0].vin[0].scriptSig = CScript() << OP_0 << OP_0;
*/
pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]); pblocktemplate->vTxSigOps[0] = GetLegacySigOpCount(pblock->vtx[0]);
CBlockIndex indexDummy(*pblock); CBlockIndex indexDummy(*pblock);
@ -4514,9 +4571,10 @@ void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int&
} }
++nExtraNonce; ++nExtraNonce;
unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2 unsigned int nHeight = pindexPrev->nHeight+1; // Height first in coinbase required for block.version=2
/* [MF] Check!
pblock->vtx[0].vin[0].scriptSig = (CScript() << nHeight << CBigNum(nExtraNonce)) + COINBASE_FLAGS; pblock->vtx[0].vin[0].scriptSig = (CScript() << nHeight << CBigNum(nExtraNonce)) + COINBASE_FLAGS;
assert(pblock->vtx[0].vin[0].scriptSig.size() <= 100); assert(pblock->vtx[0].vin[0].scriptSig.size() <= 100);
*/
pblock->hashMerkleRoot = pblock->BuildMerkleTree(); pblock->hashMerkleRoot = pblock->BuildMerkleTree();
} }
@ -4579,7 +4637,7 @@ bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)
printf("BitcoinMiner:\n"); printf("BitcoinMiner:\n");
printf("proof-of-work found \n hash: %s \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str()); printf("proof-of-work found \n hash: %s \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str());
pblock->print(); pblock->print();
printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str()); //printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str());
// Found a solution // Found a solution
{ {

3
src/main.h
View File

@ -420,7 +420,8 @@ private:
public: public:
CScriptCheck() {} CScriptCheck() {}
CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) : CScriptCheck(const CCoins& txFromIn, const CTransaction& txToIn, unsigned int nInIn, unsigned int nFlagsIn, int nHashTypeIn) :
scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey), // scriptPubKey(txFromIn.vout[txToIn.vin[nInIn].prevout.n].scriptPubKey), [MF]
scriptPubKey(),
ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { } ptxTo(&txToIn), nIn(nInIn), nFlags(nFlagsIn), nHashType(nHashTypeIn) { }
bool operator()() const; bool operator()() const;

3
src/qt/bitcoin.cpp
View File

@ -71,9 +71,10 @@ static bool ThreadSafeAskFee(int64 nFeeRequired)
{ {
if(!guiref) if(!guiref)
return false; return false;
/*
if(nFeeRequired < CTransaction::nMinTxFee || nFeeRequired <= nTransactionFee || fDaemon) if(nFeeRequired < CTransaction::nMinTxFee || nFeeRequired <= nTransactionFee || fDaemon)
return true; return true;
*/
bool payFee = false; bool payFee = false;
QMetaObject::invokeMethod(guiref, "askFee", GUIUtil::blockingGUIThreadConnection(), QMetaObject::invokeMethod(guiref, "askFee", GUIUtil::blockingGUIThreadConnection(),

9
src/qt/transactiondesc.cpp
View File

@ -14,10 +14,8 @@ QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
{ {
if (!IsFinalTx(wtx)) if (!IsFinalTx(wtx))
{ {
if (wtx.nLockTime < LOCKTIME_THRESHOLD) //if (wtx.nLockTime < LOCKTIME_THRESHOLD)
return tr("Open for %n more block(s)", "", wtx.nLockTime - nBestHeight + 1); return tr("Open for %n more block(s)", "", 0 - nBestHeight + 1);
else
return tr("Open until %1").arg(GUIUtil::dateTimeStr(wtx.nLockTime));
} }
else else
{ {
@ -34,7 +32,7 @@ QString TransactionDesc::FormatTxStatus(const CWalletTx& wtx)
QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx) QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
{ {
QString strHTML; QString strHTML;
/*
{ {
LOCK(wallet->cs_wallet); LOCK(wallet->cs_wallet);
strHTML.reserve(4000); strHTML.reserve(4000);
@ -270,5 +268,6 @@ QString TransactionDesc::toHTML(CWallet *wallet, CWalletTx &wtx)
strHTML += "</font></html>"; strHTML += "</font></html>";
} }
*/
return strHTML; return strHTML;
} }

15
src/qt/transactionrecord.cpp
View File

@ -30,7 +30,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *
int64 nNet = nCredit - nDebit; int64 nNet = nCredit - nDebit;
uint256 hash = wtx.GetHash(); uint256 hash = wtx.GetHash();
std::map<std::string, std::string> mapValue = wtx.mapValue; std::map<std::string, std::string> mapValue = wtx.mapValue;
/*
if (nNet > 0 || wtx.IsCoinBase()) if (nNet > 0 || wtx.IsCoinBase())
{ {
// //
@ -119,7 +119,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *
} }
int64 nValue = txout.nValue; int64 nValue = txout.nValue;
/* Add fee to first output */
if (nTxFee > 0) if (nTxFee > 0)
{ {
nValue += nTxFee; nValue += nTxFee;
@ -138,7 +138,7 @@ QList<TransactionRecord> TransactionRecord::decomposeTransaction(const CWallet *
parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0)); parts.append(TransactionRecord(hash, nTime, TransactionRecord::Other, "", nNet, 0));
} }
} }
*/
return parts; return parts;
} }
@ -164,15 +164,10 @@ void TransactionRecord::updateStatus(const CWalletTx &wtx)
if (!IsFinalTx(wtx)) if (!IsFinalTx(wtx))
{ {
if (wtx.nLockTime < LOCKTIME_THRESHOLD) //if (wtx.nLockTime < LOCKTIME_THRESHOLD)
{ {
status.status = TransactionStatus::OpenUntilBlock; status.status = TransactionStatus::OpenUntilBlock;
status.open_for = wtx.nLockTime - nBestHeight + 1; status.open_for = /* 0 */ - nBestHeight + 1;
}
else
{
status.status = TransactionStatus::OpenUntilDate;
status.open_for = wtx.nLockTime;
} }
} }
else else

8
src/rpcmining.cpp
View File

@ -167,7 +167,9 @@ Value getwork(const Array& params, bool fHelp)
IncrementExtraNonce(pblock, pindexPrev, nExtraNonce); IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
// Save // Save
/* [MF]
mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig); mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);
*/
// Pre-build hash buffers // Pre-build hash buffers
char pmidstate[32]; char pmidstate[32];
@ -203,7 +205,9 @@ Value getwork(const Array& params, bool fHelp)
pblock->nTime = pdata->nTime; pblock->nTime = pdata->nTime;
pblock->nNonce = pdata->nNonce; pblock->nNonce = pdata->nNonce;
/* [MF]
pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second; pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;
*/
pblock->hashMerkleRoot = pblock->BuildMerkleTree(); pblock->hashMerkleRoot = pblock->BuildMerkleTree();
return CheckWork(pblock, *pwalletMain, *pMiningKey); return CheckWork(pblock, *pwalletMain, *pMiningKey);
@ -312,11 +316,13 @@ Value getblocktemplate(const Array& params, bool fHelp)
entry.push_back(Pair("hash", txHash.GetHex())); entry.push_back(Pair("hash", txHash.GetHex()));
Array deps; Array deps;
/*
BOOST_FOREACH (const CTxIn &in, tx.vin) BOOST_FOREACH (const CTxIn &in, tx.vin)
{ {
if (setTxIndex.count(in.prevout.hash)) if (setTxIndex.count(in.prevout.hash))
deps.push_back(setTxIndex[in.prevout.hash]); deps.push_back(setTxIndex[in.prevout.hash]);
} }
*/
entry.push_back(Pair("depends", deps)); entry.push_back(Pair("depends", deps));
int index_in_template = i - 1; int index_in_template = i - 1;
@ -344,7 +350,7 @@ Value getblocktemplate(const Array& params, bool fHelp)
result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex())); result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));
result.push_back(Pair("transactions", transactions)); result.push_back(Pair("transactions", transactions));
result.push_back(Pair("coinbaseaux", aux)); result.push_back(Pair("coinbaseaux", aux));
result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue)); //result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue));
result.push_back(Pair("target", hashTarget.GetHex())); result.push_back(Pair("target", hashTarget.GetHex()));
result.push_back(Pair("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1)); result.push_back(Pair("mintime", (int64_t)pindexPrev->GetMedianTimePast()+1));
result.push_back(Pair("mutable", aMutable)); result.push_back(Pair("mutable", aMutable));

24
src/rpcrawtransaction.cpp
View File

@ -78,8 +78,9 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry)
{ {
entry.push_back(Pair("txid", tx.GetHash().GetHex())); entry.push_back(Pair("txid", tx.GetHash().GetHex()));
entry.push_back(Pair("version", tx.nVersion)); entry.push_back(Pair("version", tx.nVersion));
entry.push_back(Pair("locktime", (boost::int64_t)tx.nLockTime)); //entry.push_back(Pair("locktime", (boost::int64_t)tx.nLockTime));
Array vin; Array vin;
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
Object in; Object in;
@ -97,8 +98,10 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry)
in.push_back(Pair("sequence", (boost::int64_t)txin.nSequence)); in.push_back(Pair("sequence", (boost::int64_t)txin.nSequence));
vin.push_back(in); vin.push_back(in);
} }
*/
entry.push_back(Pair("vin", vin)); entry.push_back(Pair("vin", vin));
Array vout; Array vout;
/*
for (unsigned int i = 0; i < tx.vout.size(); i++) for (unsigned int i = 0; i < tx.vout.size(); i++)
{ {
const CTxOut& txout = tx.vout[i]; const CTxOut& txout = tx.vout[i];
@ -110,6 +113,7 @@ void TxToJSON(const CTransaction& tx, const uint256 hashBlock, Object& entry)
out.push_back(Pair("scriptPubKey", o)); out.push_back(Pair("scriptPubKey", o));
vout.push_back(out); vout.push_back(out);
} }
*/
entry.push_back(Pair("vout", vout)); entry.push_back(Pair("vout", vout));
if (hashBlock != 0) if (hashBlock != 0)
@ -212,13 +216,14 @@ Value listunspent(const Array& params, bool fHelp)
if (setAddress.size()) if (setAddress.size())
{ {
CTxDestination address; CTxDestination address;
/*
if (!ExtractDestination(out.tx->vout[out.i].scriptPubKey, address)) if (!ExtractDestination(out.tx->vout[out.i].scriptPubKey, address))
continue; continue;
*/
if (!setAddress.count(address)) if (!setAddress.count(address))
continue; continue;
} }
/*
int64 nValue = out.tx->vout[out.i].nValue; int64 nValue = out.tx->vout[out.i].nValue;
const CScript& pk = out.tx->vout[out.i].scriptPubKey; const CScript& pk = out.tx->vout[out.i].scriptPubKey;
Object entry; Object entry;
@ -246,6 +251,7 @@ Value listunspent(const Array& params, bool fHelp)
entry.push_back(Pair("amount",ValueFromAmount(nValue))); entry.push_back(Pair("amount",ValueFromAmount(nValue)));
entry.push_back(Pair("confirmations",out.nDepth)); entry.push_back(Pair("confirmations",out.nDepth));
results.push_back(entry); results.push_back(entry);
*/
} }
return results; return results;
@ -284,7 +290,7 @@ Value createrawtransaction(const Array& params, bool fHelp)
throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive"); throw JSONRPCError(RPC_INVALID_PARAMETER, "Invalid parameter, vout must be positive");
CTxIn in(COutPoint(txid, nOutput)); CTxIn in(COutPoint(txid, nOutput));
rawTx.vin.push_back(in); // [MF] rawTx.vin.push_back(in);
} }
set<CBitcoinAddress> setAddress; set<CBitcoinAddress> setAddress;
@ -303,7 +309,7 @@ Value createrawtransaction(const Array& params, bool fHelp)
int64 nAmount = AmountFromValue(s.value_); int64 nAmount = AmountFromValue(s.value_);
CTxOut out(nAmount, scriptPubKey); CTxOut out(nAmount, scriptPubKey);
rawTx.vout.push_back(out); // [MF] rawTx.vout.push_back(out);
} }
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION); CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
@ -385,11 +391,13 @@ Value signrawtransaction(const Array& params, bool fHelp)
CCoinsViewMemPool viewMempool(viewChain, mempool); CCoinsViewMemPool viewMempool(viewChain, mempool);
view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view view.SetBackend(viewMempool); // temporarily switch cache backend to db+mempool view
/*
BOOST_FOREACH(const CTxIn& txin, mergedTx.vin) { BOOST_FOREACH(const CTxIn& txin, mergedTx.vin) {
const uint256& prevHash = txin.prevout.hash; const uint256& prevHash = txin.prevout.hash;
CCoins coins; CCoins coins;
view.GetCoins(prevHash, coins); // this is certainly allowed to fail view.GetCoins(prevHash, coins); // this is certainly allowed to fail
} }
*/
view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long view.SetBackend(viewDummy); // switch back to avoid locking mempool for too long
} }
@ -445,12 +453,13 @@ Value signrawtransaction(const Array& params, bool fHelp)
} }
// what todo if txid is known, but the actual output isn't? // what todo if txid is known, but the actual output isn't?
} }
/*
if ((unsigned int)nOut >= coins.vout.size()) if ((unsigned int)nOut >= coins.vout.size())
coins.vout.resize(nOut+1); coins.vout.resize(nOut+1);
coins.vout[nOut].scriptPubKey = scriptPubKey; coins.vout[nOut].scriptPubKey = scriptPubKey;
coins.vout[nOut].nValue = 0; // we don't know the actual output value coins.vout[nOut].nValue = 0; // we don't know the actual output value
view.SetCoins(txid, coins); view.SetCoins(txid, coins);
*/
// if redeemScript given and not using the local wallet (private keys // if redeemScript given and not using the local wallet (private keys
// given), add redeemScript to the tempKeystore so it can be signed: // given), add redeemScript to the tempKeystore so it can be signed:
if (fGivenKeys && scriptPubKey.IsPayToScriptHash()) if (fGivenKeys && scriptPubKey.IsPayToScriptHash())
@ -491,6 +500,7 @@ Value signrawtransaction(const Array& params, bool fHelp)
bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE); bool fHashSingle = ((nHashType & ~SIGHASH_ANYONECANPAY) == SIGHASH_SINGLE);
// Sign what we can: // Sign what we can:
/* [MF]
for (unsigned int i = 0; i < mergedTx.vin.size(); i++) for (unsigned int i = 0; i < mergedTx.vin.size(); i++)
{ {
CTxIn& txin = mergedTx.vin[i]; CTxIn& txin = mergedTx.vin[i];
@ -515,7 +525,7 @@ Value signrawtransaction(const Array& params, bool fHelp)
if (!VerifyScript(txin.scriptSig, prevPubKey, mergedTx, i, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0)) if (!VerifyScript(txin.scriptSig, prevPubKey, mergedTx, i, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0))
fComplete = false; fComplete = false;
} }
*/
Object result; Object result;
CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION); CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION);
ssTx << mergedTx; ssTx << mergedTx;

13
src/rpcwallet.cpp
View File

@ -128,7 +128,7 @@ CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
walletdb.ReadAccount(strAccount, account); walletdb.ReadAccount(strAccount, account);
bool bKeyUsed = false; bool bKeyUsed = false;
/*
// Check if the current key has been used // Check if the current key has been used
if (account.vchPubKey.IsValid()) if (account.vchPubKey.IsValid())
{ {
@ -144,7 +144,7 @@ CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
bKeyUsed = true; bKeyUsed = true;
} }
} }
*/
// Generate a new key // Generate a new key
if (!account.vchPubKey.IsValid() || bForceNew || bKeyUsed) if (!account.vchPubKey.IsValid() || bForceNew || bKeyUsed)
{ {
@ -410,11 +410,12 @@ Value getreceivedbyaddress(const Array& params, bool fHelp)
const CWalletTx& wtx = (*it).second; const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || !IsFinalTx(wtx)) if (wtx.IsCoinBase() || !IsFinalTx(wtx))
continue; continue;
/*
BOOST_FOREACH(const CTxOut& txout, wtx.vout) BOOST_FOREACH(const CTxOut& txout, wtx.vout)
if (txout.scriptPubKey == scriptPubKey) if (txout.scriptPubKey == scriptPubKey)
if (wtx.GetDepthInMainChain() >= nMinDepth) if (wtx.GetDepthInMainChain() >= nMinDepth)
nAmount += txout.nValue; nAmount += txout.nValue;
*/
} }
return ValueFromAmount(nAmount); return ValueFromAmount(nAmount);
@ -456,7 +457,7 @@ Value getreceivedbyaccount(const Array& params, bool fHelp)
const CWalletTx& wtx = (*it).second; const CWalletTx& wtx = (*it).second;
if (wtx.IsCoinBase() || !IsFinalTx(wtx)) if (wtx.IsCoinBase() || !IsFinalTx(wtx))
continue; continue;
/*
BOOST_FOREACH(const CTxOut& txout, wtx.vout) BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{ {
CTxDestination address; CTxDestination address;
@ -464,6 +465,7 @@ Value getreceivedbyaccount(const Array& params, bool fHelp)
if (wtx.GetDepthInMainChain() >= nMinDepth) if (wtx.GetDepthInMainChain() >= nMinDepth)
nAmount += txout.nValue; nAmount += txout.nValue;
} }
*/
} }
return (double)nAmount / (double)COIN; return (double)nAmount / (double)COIN;
@ -845,7 +847,7 @@ Value ListReceived(const Array& params, bool fByAccounts)
int nDepth = wtx.GetDepthInMainChain(); int nDepth = wtx.GetDepthInMainChain();
if (nDepth < nMinDepth) if (nDepth < nMinDepth)
continue; continue;
/*
BOOST_FOREACH(const CTxOut& txout, wtx.vout) BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{ {
CTxDestination address; CTxDestination address;
@ -857,6 +859,7 @@ Value ListReceived(const Array& params, bool fByAccounts)
item.nConf = min(item.nConf, nDepth); item.nConf = min(item.nConf, nDepth);
item.txids.push_back(wtx.GetHash()); item.txids.push_back(wtx.GetHash());
} }
*/
} }
// Reply // Reply

15
src/script.cpp
View File

@ -965,13 +965,8 @@ bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, co
uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType) uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
{ {
if (nIn >= txTo.vin.size())
{
printf("ERROR: SignatureHash() : nIn=%d out of range\n", nIn);
return 1;
}
CTransaction txTmp(txTo); CTransaction txTmp(txTo);
/*
// In case concatenating two scripts ends up with two codeseparators, // In case concatenating two scripts ends up with two codeseparators,
// or an extra one at the end, this prevents all those possible incompatibilities. // or an extra one at the end, this prevents all those possible incompatibilities.
scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR)); scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
@ -1017,7 +1012,7 @@ uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int
txTmp.vin[0] = txTmp.vin[nIn]; txTmp.vin[0] = txTmp.vin[nIn];
txTmp.vin.resize(1); txTmp.vin.resize(1);
} }
*/
// Serialize and hash // Serialize and hash
CHashWriter ss(SER_GETHASH, 0); CHashWriter ss(SER_GETHASH, 0);
ss << txTmp << nHashType; ss << txTmp << nHashType;
@ -1554,6 +1549,7 @@ bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const C
bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey, CTransaction& txTo, unsigned int nIn, int nHashType) bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey, CTransaction& txTo, unsigned int nIn, int nHashType)
{ {
/*
assert(nIn < txTo.vin.size()); assert(nIn < txTo.vin.size());
CTxIn& txin = txTo.vin[nIn]; CTxIn& txin = txTo.vin[nIn];
@ -1585,16 +1581,21 @@ bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey, CTransa
// Test solution // Test solution
return VerifyScript(txin.scriptSig, fromPubKey, txTo, nIn, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0); return VerifyScript(txin.scriptSig, fromPubKey, txTo, nIn, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0);
*/
return true;
} }
bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType) bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType)
{ {
/*
assert(nIn < txTo.vin.size()); assert(nIn < txTo.vin.size());
CTxIn& txin = txTo.vin[nIn]; CTxIn& txin = txTo.vin[nIn];
assert(txin.prevout.n < txFrom.vout.size()); assert(txin.prevout.n < txFrom.vout.size());
const CTxOut& txout = txFrom.vout[txin.prevout.n]; const CTxOut& txout = txFrom.vout[txin.prevout.n];
return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType); return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType);
*/
return true;
} }
static CScript PushAll(const vector<valtype>& values) static CScript PushAll(const vector<valtype>& values)

10
src/util.cpp
View File

@ -1023,7 +1023,7 @@ boost::filesystem::path GetDefaultDataDir()
// Unix: ~/.bitcoin // Unix: ~/.bitcoin
#ifdef WIN32 #ifdef WIN32
// Windows // Windows
return GetSpecialFolderPath(CSIDL_APPDATA) / "Bitcoin"; return GetSpecialFolderPath(CSIDL_APPDATA) / "Twister";
#else #else
fs::path pathRet; fs::path pathRet;
char* pszHome = getenv("HOME"); char* pszHome = getenv("HOME");
@ -1035,10 +1035,10 @@ boost::filesystem::path GetDefaultDataDir()
// Mac // Mac
pathRet /= "Library/Application Support"; pathRet /= "Library/Application Support";
fs::create_directory(pathRet); fs::create_directory(pathRet);
return pathRet / "Bitcoin"; return pathRet / "Twister";
#else #else
// Unix // Unix
return pathRet / ".bitcoin"; return pathRet / ".twister";
#endif #endif
#endif #endif
} }
@ -1079,7 +1079,7 @@ const boost::filesystem::path &GetDataDir(bool fNetSpecific)
boost::filesystem::path GetConfigFile() boost::filesystem::path GetConfigFile()
{ {
boost::filesystem::path pathConfigFile(GetArg("-conf", "bitcoin.conf")); boost::filesystem::path pathConfigFile(GetArg("-conf", "twister.conf"));
if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir(false) / pathConfigFile; if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir(false) / pathConfigFile;
return pathConfigFile; return pathConfigFile;
} }
@ -1113,7 +1113,7 @@ void ReadConfigFile(map<string, string>& mapSettingsRet,
boost::filesystem::path GetPidFile() boost::filesystem::path GetPidFile()
{ {
boost::filesystem::path pathPidFile(GetArg("-pid", "bitcoind.pid")); boost::filesystem::path pathPidFile(GetArg("-pid", "twisterd.pid"));
if (!pathPidFile.is_complete()) pathPidFile = GetDataDir() / pathPidFile; if (!pathPidFile.is_complete()) pathPidFile = GetDataDir() / pathPidFile;
return pathPidFile; return pathPidFile;
} }

40
src/wallet.cpp
View File

@ -361,6 +361,7 @@ void CWallet::WalletUpdateSpent(const CTransaction &tx)
// restored from backup or the user making copies of wallet.dat. // restored from backup or the user making copies of wallet.dat.
{ {
LOCK(cs_wallet); LOCK(cs_wallet);
/*
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash); map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
@ -378,6 +379,7 @@ void CWallet::WalletUpdateSpent(const CTransaction &tx)
} }
} }
} }
*/
} }
} }
@ -488,6 +490,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn)
if (vchDefaultKey.IsValid()) { if (vchDefaultKey.IsValid()) {
CScript scriptDefaultKey; CScript scriptDefaultKey;
scriptDefaultKey.SetDestination(vchDefaultKey.GetID()); scriptDefaultKey.SetDestination(vchDefaultKey.GetID());
/*
BOOST_FOREACH(const CTxOut& txout, wtx.vout) BOOST_FOREACH(const CTxOut& txout, wtx.vout)
{ {
if (txout.scriptPubKey == scriptDefaultKey) if (txout.scriptPubKey == scriptDefaultKey)
@ -500,6 +503,7 @@ bool CWallet::AddToWallet(const CWalletTx& wtxIn)
} }
} }
} }
*/
} }
} }
// since AddToWallet is called directly for self-originating transactions, check for consumption of own coins // since AddToWallet is called directly for self-originating transactions, check for consumption of own coins
@ -565,9 +569,11 @@ bool CWallet::IsMine(const CTxIn &txin) const
if (mi != mapWallet.end()) if (mi != mapWallet.end())
{ {
const CWalletTx& prev = (*mi).second; const CWalletTx& prev = (*mi).second;
/*
if (txin.prevout.n < prev.vout.size()) if (txin.prevout.n < prev.vout.size())
if (IsMine(prev.vout[txin.prevout.n])) if (IsMine(prev.vout[txin.prevout.n]))
return true; return true;
*/
} }
} }
return false; return false;
@ -581,9 +587,11 @@ int64 CWallet::GetDebit(const CTxIn &txin) const
if (mi != mapWallet.end()) if (mi != mapWallet.end())
{ {
const CWalletTx& prev = (*mi).second; const CWalletTx& prev = (*mi).second;
/*
if (txin.prevout.n < prev.vout.size()) if (txin.prevout.n < prev.vout.size())
if (IsMine(prev.vout[txin.prevout.n])) if (IsMine(prev.vout[txin.prevout.n]))
return prev.vout[txin.prevout.n].nValue; return prev.vout[txin.prevout.n].nValue;
*/
} }
} }
return 0; return 0;
@ -670,6 +678,7 @@ void CWalletTx::GetAmounts(list<pair<CTxDestination, int64> >& listReceived,
nFee = nDebit - nValueOut; nFee = nDebit - nValueOut;
} }
/*
// Sent/received. // Sent/received.
BOOST_FOREACH(const CTxOut& txout, vout) BOOST_FOREACH(const CTxOut& txout, vout)
{ {
@ -691,7 +700,7 @@ void CWalletTx::GetAmounts(list<pair<CTxDestination, int64> >& listReceived,
if (pwallet->IsMine(txout)) if (pwallet->IsMine(txout))
listReceived.push_back(make_pair(address, txout.nValue)); listReceived.push_back(make_pair(address, txout.nValue));
} }
*/
} }
void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nReceived, void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nReceived,
@ -737,6 +746,7 @@ void CWalletTx::AddSupportingTransactions()
if (SetMerkleBranch() < COPY_DEPTH) if (SetMerkleBranch() < COPY_DEPTH)
{ {
vector<uint256> vWorkQueue; vector<uint256> vWorkQueue;
/*
BOOST_FOREACH(const CTxIn& txin, vin) BOOST_FOREACH(const CTxIn& txin, vin)
vWorkQueue.push_back(txin.prevout.hash); vWorkQueue.push_back(txin.prevout.hash);
@ -774,6 +784,7 @@ void CWalletTx::AddSupportingTransactions()
} }
} }
} }
*/
} }
reverse(vtxPrev.begin(), vtxPrev.end()); reverse(vtxPrev.begin(), vtxPrev.end());
@ -835,6 +846,7 @@ void CWallet::ReacceptWalletTransactions()
bool fFound = pcoinsTip->GetCoins(wtx.GetHash(), coins); bool fFound = pcoinsTip->GetCoins(wtx.GetHash(), coins);
if (fFound || wtx.GetDepthInMainChain() > 0) if (fFound || wtx.GetDepthInMainChain() > 0)
{ {
/*
// Update fSpent if a tx got spent somewhere else by a copy of wallet.dat // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
for (unsigned int i = 0; i < wtx.vout.size(); i++) for (unsigned int i = 0; i < wtx.vout.size(); i++)
{ {
@ -853,6 +865,7 @@ void CWallet::ReacceptWalletTransactions()
wtx.MarkDirty(); wtx.MarkDirty();
wtx.WriteToDisk(); wtx.WriteToDisk();
} }
*/
} }
else else
{ {
@ -1003,12 +1016,13 @@ void CWallet::AvailableCoins(vector<COutput>& vCoins, bool fOnlyConfirmed) const
if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0) if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
continue; continue;
/*
for (unsigned int i = 0; i < pcoin->vout.size(); i++) { for (unsigned int i = 0; i < pcoin->vout.size(); i++) {
if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) && if (!(pcoin->IsSpent(i)) && IsMine(pcoin->vout[i]) &&
!IsLockedCoin((*it).first, i) && pcoin->vout[i].nValue > 0) !IsLockedCoin((*it).first, i) && pcoin->vout[i].nValue > 0)
vCoins.push_back(COutput(pcoin, i, pcoin->GetDepthInMainChain())); vCoins.push_back(COutput(pcoin, i, pcoin->GetDepthInMainChain()));
} }
*/
} }
} }
} }
@ -1064,7 +1078,7 @@ bool CWallet::SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfThe
{ {
setCoinsRet.clear(); setCoinsRet.clear();
nValueRet = 0; nValueRet = 0;
/*
// List of values less than target // List of values less than target
pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger; pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
coinLowestLarger.first = std::numeric_limits<int64>::max(); coinLowestLarger.first = std::numeric_limits<int64>::max();
@ -1154,7 +1168,7 @@ bool CWallet::SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfThe
printf("%s ", FormatMoney(vValue[i].first).c_str()); printf("%s ", FormatMoney(vValue[i].first).c_str());
printf("total %s\n", FormatMoney(nBest).c_str()); printf("total %s\n", FormatMoney(nBest).c_str());
} }
*/
return true; return true;
} }
@ -1196,6 +1210,7 @@ bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend,
LOCK2(cs_main, cs_wallet); LOCK2(cs_main, cs_wallet);
{ {
nFeeRet = nTransactionFee; nFeeRet = nTransactionFee;
/*
loop loop
{ {
wtxNew.vin.clear(); wtxNew.vin.clear();
@ -1320,6 +1335,7 @@ bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend,
break; break;
} }
*/
} }
} }
return true; return true;
@ -1354,6 +1370,7 @@ bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
// Mark old coins as spent // Mark old coins as spent
set<CWalletTx*> setCoins; set<CWalletTx*> setCoins;
/*
BOOST_FOREACH(const CTxIn& txin, wtxNew.vin) BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
{ {
CWalletTx &coin = mapWallet[txin.prevout.hash]; CWalletTx &coin = mapWallet[txin.prevout.hash];
@ -1362,6 +1379,7 @@ bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
coin.WriteToDisk(); coin.WriteToDisk();
NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED); NotifyTransactionChanged(this, coin.GetHash(), CT_UPDATED);
} }
*/
if (fFileBacked) if (fFileBacked)
delete pwalletdb; delete pwalletdb;
@ -1696,7 +1714,7 @@ std::map<CTxDestination, int64> CWallet::GetAddressBalances()
int nDepth = pcoin->GetDepthInMainChain(); int nDepth = pcoin->GetDepthInMainChain();
if (nDepth < (pcoin->IsFromMe() ? 0 : 1)) if (nDepth < (pcoin->IsFromMe() ? 0 : 1))
continue; continue;
/*
for (unsigned int i = 0; i < pcoin->vout.size(); i++) for (unsigned int i = 0; i < pcoin->vout.size(); i++)
{ {
CTxDestination addr; CTxDestination addr;
@ -1710,8 +1728,9 @@ std::map<CTxDestination, int64> CWallet::GetAddressBalances()
if (!balances.count(addr)) if (!balances.count(addr))
balances[addr] = 0; balances[addr] = 0;
balances[addr] += n; balances[addr] += n;
} }*/
} }
} }
return balances; return balances;
@ -1725,7 +1744,7 @@ set< set<CTxDestination> > CWallet::GetAddressGroupings()
BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet) BOOST_FOREACH(PAIRTYPE(uint256, CWalletTx) walletEntry, mapWallet)
{ {
CWalletTx *pcoin = &walletEntry.second; CWalletTx *pcoin = &walletEntry.second;
/*
if (pcoin->vin.size() > 0) if (pcoin->vin.size() > 0)
{ {
bool any_mine = false; bool any_mine = false;
@ -1733,7 +1752,7 @@ set< set<CTxDestination> > CWallet::GetAddressGroupings()
BOOST_FOREACH(CTxIn txin, pcoin->vin) BOOST_FOREACH(CTxIn txin, pcoin->vin)
{ {
CTxDestination address; CTxDestination address;
if(!IsMine(txin)) /* If this input isn't mine, ignore it */ if(!IsMine(txin))
continue; continue;
if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address)) if(!ExtractDestination(mapWallet[txin.prevout.hash].vout[txin.prevout.n].scriptPubKey, address))
continue; continue;
@ -1771,6 +1790,7 @@ set< set<CTxDestination> > CWallet::GetAddressGroupings()
groupings.insert(grouping); groupings.insert(grouping);
grouping.clear(); grouping.clear();
} }
*/
} }
set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses set< set<CTxDestination>* > uniqueGroupings; // a set of pointers to groups of addresses
@ -1930,7 +1950,7 @@ void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64> &mapKeyBirth) const {
// if there are no such keys, we're done // if there are no such keys, we're done
if (mapKeyFirstBlock.empty()) if (mapKeyFirstBlock.empty())
return; return;
/*
// find first block that affects those keys, if there are any left // find first block that affects those keys, if there are any left
std::vector<CKeyID> vAffected; std::vector<CKeyID> vAffected;
for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) { for (std::map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); it++) {
@ -1953,7 +1973,7 @@ void CWallet::GetKeyBirthTimes(std::map<CKeyID, int64> &mapKeyBirth) const {
} }
} }
} }
*/
// Extract block timestamps for those keys // Extract block timestamps for those keys
for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++) for (std::map<CKeyID, CBlockIndex*>::const_iterator it = mapKeyFirstBlock.begin(); it != mapKeyFirstBlock.end(); it++)
mapKeyBirth[it->first] = it->second->nTime - 7200; // block times can be 2h off mapKeyBirth[it->first] = it->second->nTime - 7200; // block times can be 2h off

29
src/wallet.h
View File

@ -228,9 +228,10 @@ public:
} }
bool IsMine(const CTransaction& tx) const bool IsMine(const CTransaction& tx) const
{ {
BOOST_FOREACH(const CTxOut& txout, tx.vout) /* [MF] BOOST_FOREACH(const CTxOut& txout, tx.vout)
if (IsMine(txout)) if (IsMine(txout))
return true; return true;
*/
return false; return false;
} }
bool IsFromMe(const CTransaction& tx) const bool IsFromMe(const CTransaction& tx) const
@ -240,34 +241,40 @@ public:
int64 GetDebit(const CTransaction& tx) const int64 GetDebit(const CTransaction& tx) const
{ {
int64 nDebit = 0; int64 nDebit = 0;
/* [MF]
BOOST_FOREACH(const CTxIn& txin, tx.vin) BOOST_FOREACH(const CTxIn& txin, tx.vin)
{ {
nDebit += GetDebit(txin); nDebit += GetDebit(txin);
if (!MoneyRange(nDebit)) if (!MoneyRange(nDebit))
throw std::runtime_error("CWallet::GetDebit() : value out of range"); throw std::runtime_error("CWallet::GetDebit() : value out of range");
} }
*/
return nDebit; return nDebit;
} }
int64 GetCredit(const CTransaction& tx) const int64 GetCredit(const CTransaction& tx) const
{ {
int64 nCredit = 0; int64 nCredit = 0;
/* [MF]
BOOST_FOREACH(const CTxOut& txout, tx.vout) BOOST_FOREACH(const CTxOut& txout, tx.vout)
{ {
nCredit += GetCredit(txout); nCredit += GetCredit(txout);
if (!MoneyRange(nCredit)) if (!MoneyRange(nCredit))
throw std::runtime_error("CWallet::GetCredit() : value out of range"); throw std::runtime_error("CWallet::GetCredit() : value out of range");
} }
*/
return nCredit; return nCredit;
} }
int64 GetChange(const CTransaction& tx) const int64 GetChange(const CTransaction& tx) const
{ {
int64 nChange = 0; int64 nChange = 0;
/*
BOOST_FOREACH(const CTxOut& txout, tx.vout) BOOST_FOREACH(const CTxOut& txout, tx.vout)
{ {
nChange += GetChange(txout); nChange += GetChange(txout);
if (!MoneyRange(nChange)) if (!MoneyRange(nChange))
throw std::runtime_error("CWallet::GetChange() : value out of range"); throw std::runtime_error("CWallet::GetChange() : value out of range");
} }
*/
return nChange; return nChange;
} }
void SetBestChain(const CBlockLocator& loc); void SetBestChain(const CBlockLocator& loc);
@ -479,7 +486,7 @@ public:
READWRITE(nTimeReceived); READWRITE(nTimeReceived);
READWRITE(fFromMe); READWRITE(fFromMe);
READWRITE(fSpent); READWRITE(fSpent);
/*
if (fRead) if (fRead)
{ {
pthis->strFromAccount = pthis->mapValue["fromaccount"]; pthis->strFromAccount = pthis->mapValue["fromaccount"];
@ -494,7 +501,7 @@ public:
pthis->nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(pthis->mapValue["timesmart"]) : 0; pthis->nTimeSmart = mapValue.count("timesmart") ? (unsigned int)atoi64(pthis->mapValue["timesmart"]) : 0;
} }
*/
pthis->mapValue.erase("fromaccount"); pthis->mapValue.erase("fromaccount");
pthis->mapValue.erase("version"); pthis->mapValue.erase("version");
pthis->mapValue.erase("spent"); pthis->mapValue.erase("spent");
@ -539,7 +546,8 @@ public:
void MarkSpent(unsigned int nOut) void MarkSpent(unsigned int nOut)
{ {
if (nOut >= vout.size()) /*
if (nOut >= vout.size())
throw std::runtime_error("CWalletTx::MarkSpent() : nOut out of range"); throw std::runtime_error("CWalletTx::MarkSpent() : nOut out of range");
vfSpent.resize(vout.size()); vfSpent.resize(vout.size());
if (!vfSpent[nOut]) if (!vfSpent[nOut])
@ -547,23 +555,28 @@ public:
vfSpent[nOut] = true; vfSpent[nOut] = true;
fAvailableCreditCached = false; fAvailableCreditCached = false;
} }
*/
} }
bool IsSpent(unsigned int nOut) const bool IsSpent(unsigned int nOut) const
{ {
/*
if (nOut >= vout.size()) if (nOut >= vout.size())
throw std::runtime_error("CWalletTx::IsSpent() : nOut out of range"); throw std::runtime_error("CWalletTx::IsSpent() : nOut out of range");
if (nOut >= vfSpent.size()) if (nOut >= vfSpent.size())
return false; return false;
*/
return (!!vfSpent[nOut]); return (!!vfSpent[nOut]);
} }
int64 GetDebit() const int64 GetDebit() const
{ {
/*
if (vin.empty()) if (vin.empty())
return 0; return 0;
if (fDebitCached) if (fDebitCached)
return nDebitCached; return nDebitCached;
*/
nDebitCached = pwallet->GetDebit(*this); nDebitCached = pwallet->GetDebit(*this);
fDebitCached = true; fDebitCached = true;
return nDebitCached; return nDebitCached;
@ -607,6 +620,7 @@ public:
return nAvailableCreditCached; return nAvailableCreditCached;
int64 nCredit = 0; int64 nCredit = 0;
/*
for (unsigned int i = 0; i < vout.size(); i++) for (unsigned int i = 0; i < vout.size(); i++)
{ {
if (!IsSpent(i)) if (!IsSpent(i))
@ -617,7 +631,7 @@ public:
throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range"); throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
} }
} }
*/
nAvailableCreditCached = nCredit; nAvailableCreditCached = nCredit;
fAvailableCreditCached = true; fAvailableCreditCached = true;
return nCredit; return nCredit;
@ -676,13 +690,14 @@ public:
BOOST_FOREACH(const CMerkleTx& tx, vtxPrev) BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
mapPrev[tx.GetHash()] = &tx; mapPrev[tx.GetHash()] = &tx;
} }
/*
BOOST_FOREACH(const CTxIn& txin, ptx->vin) BOOST_FOREACH(const CTxIn& txin, ptx->vin)
{ {
if (!mapPrev.count(txin.prevout.hash)) if (!mapPrev.count(txin.prevout.hash))
return false; return false;
vWorkQueue.push_back(mapPrev[txin.prevout.hash]); vWorkQueue.push_back(mapPrev[txin.prevout.hash]);
} }
*/
} }
return true; return true;
} }
@ -714,7 +729,7 @@ public:
std::string ToString() const std::string ToString() const
{ {
return strprintf("COutput(%s, %d, %d) [%s]", tx->GetHash().ToString().c_str(), i, nDepth, FormatMoney(tx->vout[i].nValue).c_str()); return strprintf("COutput(%s, %d, %d)", tx->GetHash().ToString().c_str(), i, nDepth);
} }
void print() const void print() const