CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x55; pchMessageStart[1] = 0x42; pchMessageStart[2] = 0x4B; pchMessageStart[3] = 0x45; nDefaultPort = 11066; nRPCPort = 11067; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 100000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Viking Era"; CTransaction txNew; txNew.vin.resize(1); 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 = 0.001 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1400630400; //nTime genesis.nBits = 0x1e0fffff; genesis.nNonce = 2016973; hashGenesisBlock = genesis.GetHash(); // while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ // if (++genesis.nNonce==0) break; // hashGenesisBlock = genesis.GetHash(); //} printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000c07c30a4f74683e64ed156668e3f8d2e71bb4efcdcc44c248708d1cabf2")); assert(genesis.hashMerkleRoot == uint256("0xb8b26c88ea01ea6cbbd9fd39158f1e6cae130cc2cd5950b78727d83aa71c056d")); vSeeds.push_back(CDNSSeedData("198.46.134.15", "192.3.10.93")); vSeeds.push_back(CDNSSeedData("95.85.46.218", "81.11.246.44")); vSeeds.push_back(CDNSSeedData("108.61.10.90", "192.241.199.243")); base58Prefixes[PUBKEY_ADDRESS] = 70; base58Prefixes[SCRIPT_ADDRESS] = 132; base58Prefixes[SECRET_KEY] = 86; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x66; pchMessageStart[1] = 0x66; pchMessageStart[2] = 0x66; pchMessageStart[3] = 0x66; nDefaultPort = 24242; nRPCPort = 24243; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 35040000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Release the Kraken - www.krakencoin.com"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNewvout1nValue = 5; txNewvout2nValue = 450000 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1394270601; genesis.nBits = 0x1e0fffff; genesis.nNonce = 943874; //// debug print hashGenesisBlock = genesis.GetHash(); //while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ // if (++genesis.nNonce==0) break; //hashGenesisBlock = genesis.GetHash(); //} printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000e9d058285796d9d49c3110a98c9367d25b7ab82cab06088f29ff4160b2a")); assert(genesis.hashMerkleRoot == uint256("0x67cf79c130dc3b7f3a164ffde6d4ff3b30fb3847e649e5ab8c889cbcba8db40d")); vSeeds.push_back(CDNSSeedData("162.243.90.199", "162.243.90.199")); base58Prefixes[PUBKEY_ADDRESS] = 45; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x09; pchMessageStart[1] = 0x04; pchMessageStart[2] = 0x04; pchMessageStart[3] = 0x05; nDefaultPort = 7777; nRPCPort = 7070; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 250000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Pump dump sell buy hold but when you hear the thunder be ready bc it will be showtimeee"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1387754247; genesis.nBits = 0x1e0fffff; genesis.nNonce = 416023; //// debug print hashGenesisBlock = genesis.GetHash(); while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ if (++genesis.nNonce==0) break; hashGenesisBlock = genesis.GetHash(); } printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000a26ae3a3e42c19266cdcb6c1705c644f6e12eff14ed69384ae9415f555d")); assert(genesis.hashMerkleRoot == uint256("0xcbe518469ca4a98504a704913d2e3b4c0a131c8734a21aa8e56f879071e5c3fc")); vSeeds.push_back(CDNSSeedData("70.193.4.56", "70.193.4.56")); base58Prefixes[PUBKEY_ADDRESS] = 127; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x02; pchMessageStart[1] = 0x03; pchMessageStart[2] = 0x04; pchMessageStart[3] = 0x05; nDefaultPort = 25535; nRPCPort = 25536; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 86400; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Lumberjacks and Maple Trees in the Great White North"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1390857400; genesis.nBits = 0x1e0fffff; genesis.nNonce = 102200; //// debug print hashGenesisBlock = genesis.GetHash(); while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ if (++genesis.nNonce==0) break; hashGenesisBlock = genesis.GetHash(); } printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000567bbebf0cde56b9d36d3476eb1ea5c5060a45006e3523e5eaab5e5e212")); assert(genesis.hashMerkleRoot == uint256("0xb929ecd9c646676b88098ad7a1031e0ab2baf390901083e3f22292b26d8c50b4")); vSeeds.push_back(CDNSSeedData("andarazoroflove.org", "andarazoroflove.org")); base58Prefixes[PUBKEY_ADDRESS] = 28; base58Prefixes[SCRIPT_ADDRESS] = 28; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0xfd; pchMessageStart[1] = 0xa4; pchMessageStart[2] = 0xdc; pchMessageStart[3] = 0x6c; vAlertPubKey = ParseHex("04d1832d7d0c59634d67d3023379403014c2878d0c2372d175219063a48fa06e6d429e09f36d3196ec544c2cfdd12d6fe510a399595f75ebb6da238eb5f70f2072"); nDefaultPort = 12340; nRPCPort = 12341; bnProofOfWorkLimit[ALGO_SHA256D] = CBigNum(~uint256(0) >> 20); // 1.00000000 bnProofOfWorkLimit[ALGO_SCRYPT] = CBigNum(~uint256(0) >> 20); bnProofOfWorkLimit[ALGO_GROESTL] = CBigNum(~uint256(0) >> 20); // 0.00195311 bnProofOfWorkLimit[ALGO_SKEIN] = CBigNum(~uint256(0) >> 20); // 0.00195311 bnProofOfWorkLimit[ALGO_QUBIT] = CBigNum(~uint256(0) >> 20); // 0.00097655 // Build the genesis block. const char* pszTimestamp = "Visir 10. oktober 2008 Gjaldeyrishoft sett a Islendinga"; CTransaction txNew; txNew.vin.resize(1); txNew.vout.resize(1); txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << std::vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp)); txNew.vout[0].nValue = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("04a5814813115273a109cff99907ba4a05d951873dae7acb6c973d0c9e7c88911a3dbc9aa600deac241b91707e7b4ffb30ad91c8e56e695a1ddf318592988afe0a") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1390598806; genesis.nBits = Params().ProofOfWorkLimit(ALGO_SCRYPT).GetCompact(); //genesis.nBits = 0x1e0fffff; genesis.nNonce = 538548; hashGenesisBlock = genesis.GetHash(); assert(hashGenesisBlock == uint256("0x2a8e100939494904af825b488596ddd536b3a96226ad02e0f7ab7ae472b27a8e")); assert(genesis.hashMerkleRoot == uint256("0x8957e5e8d2f0e90c42e739ec62fcc5dd21064852da64b6528ebd46567f222169")); vSeeds.push_back(CDNSSeedData("luxembourgh", "s1.auroraseed.net")); vSeeds.push_back(CDNSSeedData("united-states-west", "aurseed1.criptoe.com")); vSeeds.push_back(CDNSSeedData("united-states-east", "s1.auroraseed.com")); vSeeds.push_back(CDNSSeedData("iceland", "s1.auroraseed.org")); vSeeds.push_back(CDNSSeedData("the-netherlands", "s1.auroraseed.eu")); vSeeds.push_back(CDNSSeedData("electrum2", "electrum2.aurorcoin.is")); vSeeds.push_back(CDNSSeedData("electrum3", "electrum3.auroracoin.is")); vSeeds.push_back(CDNSSeedData("electrum4", "electrum4.auroracoin.is")); base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,23); base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,5); base58Prefixes[SECRET_KEY] = std::vector<unsigned char>(1,176); base58Prefixes[SECRET_KEY_OLD] = std::vector<unsigned char>(1,151); base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x88)(0xB2)(0x1E).convert_to_container<std::vector<unsigned char> >(); base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x88)(0xAD)(0xE4).convert_to_container<std::vector<unsigned char> >(); // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { const int64_t nOneWeek = 7*24*60*60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nOneWeek) - nOneWeek; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x64; pchMessageStart[1] = 0x72; pchMessageStart[2] = 0xe8; pchMessageStart[3] = 0xa6; vAlertPubKey = ParseHex("04a82e43bebee0af77bb6d4f830c5b2095b7479a480e91bbbf3547fb261c5e6d1be2c27e3c57503f501480f5027371ec62b2be1b6f00fc746e4b3777259e7f6a78"); nDefaultPort = 62621; nRPCPort = 6420; bnProofOfWorkLimit[ALGO_SHA256D] = CBigNum(~uint256(0) >> 20); bnProofOfWorkLimit[ALGO_SCRYPT] = CBigNum(~uint256(0) >> 20); bnProofOfWorkLimit[ALGO_GROESTL] = CBigNum(~uint256(0) >> 20); //nSubsidyHalvingInterval = 524160; // ~ every 6 months (2880 blocks per day including all algorithms) // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Ukraine nearing point of no return - UN"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("04e941763c7750969e751bee1ffbe96a651a0feb131db046546c219ea40bff40b95077dc9ba1c05af991588772d8daabbda57386c068fb9bc7477c5e28702d5eb9") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = BLOCK_VERSION_DEFAULT; genesis.nTime = 1400582300; genesis.nBits = 0x1e0fffff; genesis.nNonce = 263480; //// debug print hashGenesisBlock = genesis.GetHash(); while (hashGenesisBlock > bnProofOfWorkLimit[ALGO_SCRYPT].getuint256()){ if (++genesis.nNonce==0) break; hashGenesisBlock = genesis.GetHash(); } printf("MAIN: %s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit[ALGO_SHA256D].GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x000003070f466e13150a395e05856c99c5f70f9934e1d1cc0aa6dd8024de7743")); assert(genesis.hashMerkleRoot == uint256("0xda9dc50395fb1134b8bf04ffff1963ee78b1d7c4b423466b85a5ed352ded5cf5")); //vSeeds.push_back(CDNSSeedData("trinity.com", "trinity.com")); //vSeeds.push_back(CDNSSeedData("182.18.175.110", "182.18.175.110")); base58Prefixes[PUBKEY_ADDRESS] = 30; //Trinity address starts with D base58Prefixes[SCRIPT_ADDRESS] = 5; base58Prefixes[SECRET_KEY] = 177; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
AccumulatorProofOfKnowledge::AccumulatorProofOfKnowledge(const AccumulatorAndProofParams* p, const Commitment& commitmentToCoin, const AccumulatorWitness& witness): params(p) { CBigNum sg = params->accumulatorPoKCommitmentGroup.g; CBigNum sh = params->accumulatorPoKCommitmentGroup.h; CBigNum g_n = params->accumulatorQRNCommitmentGroup.g; CBigNum h_n = params->accumulatorQRNCommitmentGroup.h; CBigNum e = commitmentToCoin.getContents(); CBigNum r = commitmentToCoin.getRandomness(); CBigNum aM_4 = params->accumulatorModulus/CBigNum((long)4); CBigNum aR = CBigNum(2).pow(params->k_prime + params->k_dprime); CBigNum aR_t_aM_4 = aM_4 * aR; CBigNum r_1 = CBigNum::randBignum(aM_4); CBigNum r_2 = CBigNum::randBignum(aM_4); CBigNum r_3 = CBigNum::randBignum(aM_4); this->C_e = g_n.pow_mod(e, params->accumulatorModulus) * h_n.pow_mod(r_1, params->accumulatorModulus); this->C_u = witness.getValue() * h_n.pow_mod(r_2, params->accumulatorModulus); this->C_r = g_n.pow_mod(r_2, params->accumulatorModulus) * h_n.pow_mod(r_3, params->accumulatorModulus); CBigNum r_alpha = CBigNum::randBignum(params->maxCoinValue * aR); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_alpha = 0-r_alpha; } CBigNum r_gamma = CBigNum::randBignum(params->accumulatorPoKCommitmentGroup.modulus); CBigNum r_phi = CBigNum::randBignum(params->accumulatorPoKCommitmentGroup.modulus); CBigNum r_psi = CBigNum::randBignum(params->accumulatorPoKCommitmentGroup.modulus); CBigNum r_sigma = CBigNum::randBignum(params->accumulatorPoKCommitmentGroup.modulus); CBigNum r_xi = CBigNum::randBignum(params->accumulatorPoKCommitmentGroup.modulus); CBigNum r_epsilon = CBigNum::randBignum(aR_t_aM_4); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_epsilon = 0-r_epsilon; } CBigNum r_eta = CBigNum::randBignum(aR_t_aM_4); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_eta = 0-r_eta; } CBigNum r_zeta = CBigNum::randBignum(aR_t_aM_4); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_zeta = 0-r_zeta; } CBigNum r_beta = CBigNum::randBignum(aR_t_aM_4 * params->accumulatorPoKCommitmentGroup.modulus); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_beta = 0-r_beta; } CBigNum r_delta = CBigNum::randBignum(aR_t_aM_4 * params->accumulatorPoKCommitmentGroup.modulus); if(!(CBigNum::randBignum(CBigNum(3)) % 2)) { r_delta = 0-r_delta; } this->st_1 = (sg.pow_mod(r_alpha, params->accumulatorPoKCommitmentGroup.modulus) * sh.pow_mod(r_phi, params->accumulatorPoKCommitmentGroup.modulus)) % params->accumulatorPoKCommitmentGroup.modulus; this->st_2 = (((commitmentToCoin.getCommitmentValue() * sg.inverse(params->accumulatorPoKCommitmentGroup.modulus)).pow_mod(r_gamma, params->accumulatorPoKCommitmentGroup.modulus)) * sh.pow_mod(r_psi, params->accumulatorPoKCommitmentGroup.modulus)) % params->accumulatorPoKCommitmentGroup.modulus; this->st_3 = ((sg * commitmentToCoin.getCommitmentValue()).pow_mod(r_sigma, params->accumulatorPoKCommitmentGroup.modulus) * sh.pow_mod(r_xi, params->accumulatorPoKCommitmentGroup.modulus)) % params->accumulatorPoKCommitmentGroup.modulus; this->t_1 = (h_n.pow_mod(r_zeta, params->accumulatorModulus) * g_n.pow_mod(r_epsilon, params->accumulatorModulus)) % params->accumulatorModulus; this->t_2 = (h_n.pow_mod(r_eta, params->accumulatorModulus) * g_n.pow_mod(r_alpha, params->accumulatorModulus)) % params->accumulatorModulus; this->t_3 = (C_u.pow_mod(r_alpha, params->accumulatorModulus) * ((h_n.inverse(params->accumulatorModulus)).pow_mod(r_beta, params->accumulatorModulus))) % params->accumulatorModulus; this->t_4 = (C_r.pow_mod(r_alpha, params->accumulatorModulus) * ((h_n.inverse(params->accumulatorModulus)).pow_mod(r_delta, params->accumulatorModulus)) * ((g_n.inverse(params->accumulatorModulus)).pow_mod(r_beta, params->accumulatorModulus))) % params->accumulatorModulus; CHashWriter hasher(0,0); hasher << *params << sg << sh << g_n << h_n << commitmentToCoin.getCommitmentValue() << C_e << C_u << C_r << st_1 << st_2 << st_3 << t_1 << t_2 << t_3 << t_4; //According to the proof, this hash should be of length k_prime bits. It is currently greater than that, which should not be a problem, but we should check this. CBigNum c = CBigNum(hasher.GetHash()); this->s_alpha = r_alpha - c*e; this->s_beta = r_beta - c*r_2*e; this->s_zeta = r_zeta - c*r_3; this->s_sigma = r_sigma - c*((e+1).inverse(params->accumulatorPoKCommitmentGroup.groupOrder)); this->s_eta = r_eta - c*r_1; this->s_epsilon = r_epsilon - c*r_2; this->s_delta = r_delta - c*r_3*e; this->s_xi = r_xi + c*r*((e+1).inverse(params->accumulatorPoKCommitmentGroup.groupOrder)); this->s_phi = (r_phi - c*r) % params->accumulatorPoKCommitmentGroup.groupOrder; this->s_gamma = r_gamma - c*((e-1).inverse(params->accumulatorPoKCommitmentGroup.groupOrder)); this->s_psi = r_psi + c*r*((e-1).inverse(params->accumulatorPoKCommitmentGroup.groupOrder)); }
// If genesis block hash does not match, then generate new genesis hash. if (block.GetHash() != hashGenesisBlock) { printf("Searching for genesis block...\n"); // This will figure out a valid hash and Nonce if you're // creating a different genesis block: uint256 hashTarget = CBigNum().SetCompact(block.nBits).getuint256(); uint256 thash; while(true) { thash = scrypt_blockhash(BEGIN(block.nVersion)); if (thash <= hashTarget) break; if ((block.nNonce & 0xFFF) == 0) { printf("nonce %08X: hash = %s (target = %s)\n", block.nNonce, thash.ToString().c_str(), hashTarget.ToString().c_str()); } ++block.nNonce; if (block.nNonce == 0) { printf("NONCE WRAPPED, incrementing time\n"); ++block.nTime; } } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x05; pchMessageStart[1] = 0x05; pchMessageStart[2] = 0xb5; pchMessageStart[3] = 0x05; nDefaultPort = 5530; nRPCPort = 5531; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 100000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "vcoin sn"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1431517588; genesis.nBits = 0x1e0fffff; genesis.nNonce = 1486592; //// debug print hashGenesisBlock = genesis.GetHash(); while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ if (++genesis.nNonce==0) break; hashGenesisBlock = genesis.GetHash(); } printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000b7e804f0de87e7752550ff04d7686a4599509897feefd7f03904eb45633")); assert(genesis.hashMerkleRoot == uint256("0x1576ef41775095b26a8f8f2bb65b693ec12230608a425aa84ee462381cae00e6")); vSeeds.push_back(CDNSSeedData("1", "108.61.10.90")); vSeeds.push_back(CDNSSeedData("2", "185.92.222.31")); base58Prefixes[PUBKEY_ADDRESS] = 70; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
Shamir::Shamir(unsigned char shares, unsigned char quorum, CBigNum order) : _shares(shares), _quorum(quorum), _order(order) { if (_order == CBigNum(0)) { Key key(CBigNum((123))); _order = key.order(); } }
CBigNum Shamir::rnd() const { uint256 r; RAND_bytes((unsigned char*)&r, 32); return CBigNum(r) % _order; }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x12; pchMessageStart[1] = 0x0c; pchMessageStart[2] = 0x07; pchMessageStart[3] = 0xdd; nDefaultPort = 18123; nRPCPort = 18124; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); //nSubsidyHalvingInterval = 100000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "LeaCoin - for Lea, my little sweetie. :-)"; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1387357200; genesis.nBits = 0x1e0fffff; genesis.nNonce = 647623; //// debug print hashGenesisBlock = genesis.GetHash(); //while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ // if (++genesis.nNonce==0) break; // hashGenesisBlock = genesis.GetHash(); //} printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x00000a33e2728123ae58837d86248e19c3530a603aa9b59228fc9954ef2c93e0")); assert(genesis.hashMerkleRoot == uint256("0x448cd8630d0904ac9bb61d6fb51a0c3b25b707913b3f5a91af4e2220934690da")); vSeeds.push_back(CDNSSeedData("leacoin.org", "dnsseed.leacoin.org")); base58Prefixes[PUBKEY_ADDRESS] = 48; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0xad; pchMessageStart[1] = 0xe2; pchMessageStart[2] = 0xa1; pchMessageStart[3] = 0x90; nDefaultPort = 23932; nRPCPort = 32923; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 0; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "This is the world we live in and these are the hands we're given."; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1392595200; genesis.nBits = 0x1e0fffff; genesis.nNonce = 2738830; //// debug print hashGenesisBlock = genesis.GetHash(); //while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ // if (++genesis.nNonce==0) break; // hashGenesisBlock = genesis.GetHash(); //} printf("GenesisBlock: %s\n", hashGenesisBlock.ToString().c_str()); printf("MerkleRoot: %s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("POW: %x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x000009a51c200aab09325f0000cd965c222c20c35918eec84ce58683b0af559b")); assert(genesis.hashMerkleRoot == uint256("0x3678ae3b699a65baf9a24bf4845975d1269a92c86274908a50a7a2e4f06342eb")); vSeeds.push_back(CDNSSeedData("162.243.147.115", "162.243.147.115")); base58Prefixes[PUBKEY_ADDRESS] = 117; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType) { CAutoBN_CTX pctx; CScript::const_iterator pc = script.begin(); CScript::const_iterator pend = script.end(); CScript::const_iterator pbegincodehash = script.begin(); opcodetype opcode; valtype vchPushValue; vector<bool> vfExec; vector<valtype> altstack; if (script.size() > 10000) return false; int nOpCount = 0; try { while (pc < pend) { bool fExec = !count(vfExec.begin(), vfExec.end(), false); // // Read instruction // if (!script.GetOp(pc, opcode, vchPushValue)) return false; if (vchPushValue.size() > 520) return false; if (opcode > OP_16 && ++nOpCount > 201) return false; if (opcode == OP_CAT || opcode == OP_SUBSTR || opcode == OP_LEFT || opcode == OP_RIGHT || opcode == OP_INVERT || opcode == OP_AND || opcode == OP_OR || opcode == OP_XOR || opcode == OP_2MUL || opcode == OP_2DIV || opcode == OP_MUL || opcode == OP_DIV || opcode == OP_MOD || opcode == OP_LSHIFT || opcode == OP_RSHIFT) return false; if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) stack.push_back(vchPushValue); else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF)) switch (opcode) { // // Push value // case OP_1NEGATE: case OP_1: case OP_2: case OP_3: case OP_4: case OP_5: case OP_6: case OP_7: case OP_8: case OP_9: case OP_10: case OP_11: case OP_12: case OP_13: case OP_14: case OP_15: case OP_16: { // ( -- value) CBigNum bn((int)opcode - (int)(OP_1 - 1)); stack.push_back(bn.getvch()); } break; // // Control // case OP_NOP: case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5: case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10: break; case OP_IF: case OP_NOTIF: { // <expression> if [statements] [else [statements]] endif bool fValue = false; if (fExec) { if (stack.size() < 1) return false; valtype& vch = stacktop(-1); fValue = CastToBool(vch); if (opcode == OP_NOTIF) fValue = !fValue; popstack(stack); } vfExec.push_back(fValue); } break; case OP_ELSE: { if (vfExec.empty()) return false; vfExec.back() = !vfExec.back(); } break; case OP_ENDIF: { if (vfExec.empty()) return false; vfExec.pop_back(); } break; case OP_VERIFY: { // (true -- ) or // (false -- false) and return if (stack.size() < 1) return false; bool fValue = CastToBool(stacktop(-1)); if (fValue) popstack(stack); else return false; } break; case OP_RETURN: { return false; } break; // // Stack ops // case OP_TOALTSTACK: { if (stack.size() < 1) return false; altstack.push_back(stacktop(-1)); popstack(stack); } break; case OP_FROMALTSTACK: { if (altstack.size() < 1) return false; stack.push_back(altstacktop(-1)); popstack(altstack); } break; case OP_2DROP: { // (x1 x2 -- ) if (stack.size() < 2) return false; popstack(stack); popstack(stack); } break; case OP_2DUP: { // (x1 x2 -- x1 x2 x1 x2) if (stack.size() < 2) return false; valtype vch1 = stacktop(-2); valtype vch2 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_3DUP: { // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3) if (stack.size() < 3) return false; valtype vch1 = stacktop(-3); valtype vch2 = stacktop(-2); valtype vch3 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); stack.push_back(vch3); } break; case OP_2OVER: { // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2) if (stack.size() < 4) return false; valtype vch1 = stacktop(-4); valtype vch2 = stacktop(-3); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2ROT: { // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2) if (stack.size() < 6) return false; valtype vch1 = stacktop(-6); valtype vch2 = stacktop(-5); stack.erase(stack.end()-6, stack.end()-4); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2SWAP: { // (x1 x2 x3 x4 -- x3 x4 x1 x2) if (stack.size() < 4) return false; swap(stacktop(-4), stacktop(-2)); swap(stacktop(-3), stacktop(-1)); } break; case OP_IFDUP: { // (x - 0 | x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); if (CastToBool(vch)) stack.push_back(vch); } break; case OP_DEPTH: { // -- stacksize CBigNum bn(stack.size()); stack.push_back(bn.getvch()); } break; case OP_DROP: { // (x -- ) if (stack.size() < 1) return false; popstack(stack); } break; case OP_DUP: { // (x -- x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); stack.push_back(vch); } break; case OP_NIP: { // (x1 x2 -- x2) if (stack.size() < 2) return false; stack.erase(stack.end() - 2); } break; case OP_OVER: { // (x1 x2 -- x1 x2 x1) if (stack.size() < 2) return false; valtype vch = stacktop(-2); stack.push_back(vch); } break; case OP_PICK: case OP_ROLL: { // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn) // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn) if (stack.size() < 2) return false; int n = CastToBigNum(stacktop(-1)).getint(); popstack(stack); if (n < 0 || n >= stack.size()) return false; valtype vch = stacktop(-n-1); if (opcode == OP_ROLL) stack.erase(stack.end()-n-1); stack.push_back(vch); } break; case OP_ROT: { // (x1 x2 x3 -- x2 x3 x1) // x2 x1 x3 after first swap // x2 x3 x1 after second swap if (stack.size() < 3) return false; swap(stacktop(-3), stacktop(-2)); swap(stacktop(-2), stacktop(-1)); } break; case OP_SWAP: { // (x1 x2 -- x2 x1) if (stack.size() < 2) return false; swap(stacktop(-2), stacktop(-1)); } break; case OP_TUCK: { // (x1 x2 -- x2 x1 x2) if (stack.size() < 2) return false; valtype vch = stacktop(-1); stack.insert(stack.end()-2, vch); } break; // // Splice ops // case OP_CAT: { // (x1 x2 -- out) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); vch1.insert(vch1.end(), vch2.begin(), vch2.end()); popstack(stack); if (stacktop(-1).size() > 520) return false; } break; case OP_SUBSTR: { // (in begin size -- out) if (stack.size() < 3) return false; valtype& vch = stacktop(-3); int nBegin = CastToBigNum(stacktop(-2)).getint(); int nEnd = nBegin + CastToBigNum(stacktop(-1)).getint(); if (nBegin < 0 || nEnd < nBegin) return false; if (nBegin > vch.size()) nBegin = vch.size(); if (nEnd > vch.size()) nEnd = vch.size(); vch.erase(vch.begin() + nEnd, vch.end()); vch.erase(vch.begin(), vch.begin() + nBegin); popstack(stack); popstack(stack); } break; case OP_LEFT: case OP_RIGHT: { // (in size -- out) if (stack.size() < 2) return false; valtype& vch = stacktop(-2); int nSize = CastToBigNum(stacktop(-1)).getint(); if (nSize < 0) return false; if (nSize > vch.size()) nSize = vch.size(); if (opcode == OP_LEFT) vch.erase(vch.begin() + nSize, vch.end()); else vch.erase(vch.begin(), vch.end() - nSize); popstack(stack); } break; case OP_SIZE: { // (in -- in size) if (stack.size() < 1) return false; CBigNum bn(stacktop(-1).size()); stack.push_back(bn.getvch()); } break; // // Bitwise logic // case OP_INVERT: { // (in - out) if (stack.size() < 1) return false; valtype& vch = stacktop(-1); for (int i = 0; i < vch.size(); i++) vch[i] = ~vch[i]; } break; case OP_AND: case OP_OR: case OP_XOR: { // (x1 x2 - out) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); MakeSameSize(vch1, vch2); if (opcode == OP_AND) { for (int i = 0; i < vch1.size(); i++) vch1[i] &= vch2[i]; } else if (opcode == OP_OR) { for (int i = 0; i < vch1.size(); i++) vch1[i] |= vch2[i]; } else if (opcode == OP_XOR) { for (int i = 0; i < vch1.size(); i++) vch1[i] ^= vch2[i]; } popstack(stack); } break; case OP_EQUAL: case OP_EQUALVERIFY: //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL { // (x1 x2 - bool) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); bool fEqual = (vch1 == vch2); // OP_NOTEQUAL is disabled because it would be too easy to say // something like n != 1 and have some wiseguy pass in 1 with extra // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001) //if (opcode == OP_NOTEQUAL) // fEqual = !fEqual; popstack(stack); popstack(stack); stack.push_back(fEqual ? vchTrue : vchFalse); if (opcode == OP_EQUALVERIFY) { if (fEqual) popstack(stack); else return false; } } break; // // Numeric // case OP_1ADD: case OP_1SUB: case OP_2MUL: case OP_2DIV: case OP_NEGATE: case OP_ABS: case OP_NOT: case OP_0NOTEQUAL: { // (in -- out) if (stack.size() < 1) return false; CBigNum bn = CastToBigNum(stacktop(-1)); switch (opcode) { case OP_1ADD: bn += bnOne; break; case OP_1SUB: bn -= bnOne; break; case OP_2MUL: bn <<= 1; break; case OP_2DIV: bn >>= 1; break; case OP_NEGATE: bn = -bn; break; case OP_ABS: if (bn < bnZero) bn = -bn; break; case OP_NOT: bn = (bn == bnZero); break; case OP_0NOTEQUAL: bn = (bn != bnZero); break; } popstack(stack); stack.push_back(bn.getvch()); } break; case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_MOD: case OP_LSHIFT: case OP_RSHIFT: case OP_BOOLAND: case OP_BOOLOR: case OP_NUMEQUAL: case OP_NUMEQUALVERIFY: case OP_NUMNOTEQUAL: case OP_LESSTHAN: case OP_GREATERTHAN: case OP_LESSTHANOREQUAL: case OP_GREATERTHANOREQUAL: case OP_MIN: case OP_MAX: { // (x1 x2 -- out) if (stack.size() < 2) return false; CBigNum bn1 = CastToBigNum(stacktop(-2)); CBigNum bn2 = CastToBigNum(stacktop(-1)); CBigNum bn; switch (opcode) { case OP_ADD: bn = bn1 + bn2; break; case OP_SUB: bn = bn1 - bn2; break; case OP_MUL: if (!BN_mul(&bn, &bn1, &bn2, pctx)) return false; break; case OP_DIV: if (!BN_div(&bn, NULL, &bn1, &bn2, pctx)) return false; break; case OP_MOD: if (!BN_mod(&bn, &bn1, &bn2, pctx)) return false; break; case OP_LSHIFT: if (bn2 < bnZero || bn2 > CBigNum(2048)) return false; bn = bn1 << bn2.getulong(); break; case OP_RSHIFT: if (bn2 < bnZero || bn2 > CBigNum(2048)) return false; bn = bn1 >> bn2.getulong(); break; case OP_BOOLAND: bn = (bn1 != bnZero && bn2 != bnZero); break; case OP_BOOLOR: bn = (bn1 != bnZero || bn2 != bnZero); break; case OP_NUMEQUAL: bn = (bn1 == bn2); break; case OP_NUMEQUALVERIFY: bn = (bn1 == bn2); break; case OP_NUMNOTEQUAL: bn = (bn1 != bn2); break; case OP_LESSTHAN: bn = (bn1 < bn2); break; case OP_GREATERTHAN: bn = (bn1 > bn2); break; case OP_LESSTHANOREQUAL: bn = (bn1 <= bn2); break; case OP_GREATERTHANOREQUAL: bn = (bn1 >= bn2); break; case OP_MIN: bn = (bn1 < bn2 ? bn1 : bn2); break; case OP_MAX: bn = (bn1 > bn2 ? bn1 : bn2); break; } popstack(stack); popstack(stack); stack.push_back(bn.getvch()); if (opcode == OP_NUMEQUALVERIFY) { if (CastToBool(stacktop(-1))) popstack(stack); else return false; } } break; case OP_WITHIN: { // (x min max -- out) if (stack.size() < 3) return false; CBigNum bn1 = CastToBigNum(stacktop(-3)); CBigNum bn2 = CastToBigNum(stacktop(-2)); CBigNum bn3 = CastToBigNum(stacktop(-1)); bool fValue = (bn2 <= bn1 && bn1 < bn3); popstack(stack); popstack(stack); popstack(stack); stack.push_back(fValue ? vchTrue : vchFalse); } break; // // Crypto // case OP_RIPEMD160: case OP_SHA1: case OP_SHA256: case OP_HASH160: case OP_HASH256: { // (in -- hash) if (stack.size() < 1) return false; valtype& vch = stacktop(-1); valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32); if (opcode == OP_RIPEMD160) RIPEMD160(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_SHA1) SHA1(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_SHA256) SHA256(&vch[0], vch.size(), &vchHash[0]); else if (opcode == OP_HASH160) { uint160 hash160 = Hash160(vch); memcpy(&vchHash[0], &hash160, sizeof(hash160)); } else if (opcode == OP_HASH256) { uint256 hash = Hash(vch.begin(), vch.end()); memcpy(&vchHash[0], &hash, sizeof(hash)); } popstack(stack); stack.push_back(vchHash); } break; case OP_CODESEPARATOR: { // Hash starts after the code separator pbegincodehash = pc; } break; case OP_CHECKSIG: case OP_CHECKSIGVERIFY: { // (sig pubkey -- bool) if (stack.size() < 2) return false; valtype& vchSig = stacktop(-2); valtype& vchPubKey = stacktop(-1); ////// debug print //PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n"); //PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n"); // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signature, since there's no way for a signature to sign itself scriptCode.FindAndDelete(CScript(vchSig)); bool fSuccess = CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType); popstack(stack); popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKSIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; case OP_CHECKMULTISIG: case OP_CHECKMULTISIGVERIFY: { // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool) int i = 1; if (stack.size() < i) return false; int nKeysCount = CastToBigNum(stacktop(-i)).getint(); if (nKeysCount < 0 || nKeysCount > 20) return false; nOpCount += nKeysCount; if (nOpCount > 201) return false; int ikey = ++i; i += nKeysCount; if (stack.size() < i) return false; int nSigsCount = CastToBigNum(stacktop(-i)).getint(); if (nSigsCount < 0 || nSigsCount > nKeysCount) return false; int isig = ++i; i += nSigsCount; if (stack.size() < i) return false; // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signatures, since there's no way for a signature to sign itself for (int k = 0; k < nSigsCount; k++) { valtype& vchSig = stacktop(-isig-k); scriptCode.FindAndDelete(CScript(vchSig)); } bool fSuccess = true; while (fSuccess && nSigsCount > 0) { valtype& vchSig = stacktop(-isig); valtype& vchPubKey = stacktop(-ikey); // Check signature if (CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType)) { isig++; nSigsCount--; } ikey++; nKeysCount--; // If there are more signatures left than keys left, // then too many signatures have failed if (nSigsCount > nKeysCount) fSuccess = false; } while (i-- > 0) popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKMULTISIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; default: return false; } // Size limits if (stack.size() + altstack.size() > 1000) return false; } } catch (...) { return false; } if (!vfExec.empty()) return false; return true; }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0xf8; pchMessageStart[1] = 0xb5; pchMessageStart[2] = 0x03; pchMessageStart[3] = 0xdf; vAlertPubKey = ParseHex("04f09702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284"); nDefaultPort = 12835; nRPCPort = 12832; bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 950000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "February 5, 2014: The Black Hills are not for sale - 1868 Is The LAW!"; CTransaction txNew; txNew.vin.resize(1); 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 = 5000 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1390747675; genesis.nBits = 0x1e0ffff0; genesis.nNonce = 2091390249; //// debug print hashGenesisBlock = genesis.GetHash(); //while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ // if (++genesis.nNonce==0) break; // hashGenesisBlock = genesis.GetHash(); //} //printf("%s\n", hashGenesisBlock.ToString().c_str()); //printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); //printf("%x\n", bnProofOfWorkLimit.GetCompact()); //genesis.print(); assert(hashGenesisBlock == uint256("0x00000c7c73d8ce604178dae13f0fc6ec0be3275614366d44b1b4b5c6e238c60c")); assert(genesis.hashMerkleRoot == uint256("0x62d496378e5834989dd9594cfc168dbb76f84a39bbda18286cddc7d1d1589f4f")); vSeeds.push_back(CDNSSeedData("node.Maza.org", "node.Maza.org")); vSeeds.push_back(CDNSSeedData("node.Maza.cf", "node.Maza.cf")); vSeeds.push_back(CDNSSeedData("Maza.no-ip.org", "Maza.no-ip.org")); base58Prefixes[PUBKEY_ADDRESS] = 50; base58Prefixes[SCRIPT_ADDRESS] = 9; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
SerialNumberSignatureOfKnowledge::SerialNumberSignatureOfKnowledge(const ZerocoinParams* p, const PrivateCoin& coin, const Commitment& commitmentToCoin, uint256 msghash):params(p), s_notprime(p->zkp_iterations), sprime(p->zkp_iterations) { // Sanity check: verify that the order of the "accumulatedValueCommitmentGroup" is // equal to the modulus of "coinCommitmentGroup". Otherwise we will produce invalid // proofs. if (params->coinCommitmentGroup.modulus != params->serialNumberSoKCommitmentGroup.groupOrder) { throw std::runtime_error("Groups are not structured correctly."); } CBigNum a = params->coinCommitmentGroup.g; CBigNum b = params->coinCommitmentGroup.h; CBigNum g = params->serialNumberSoKCommitmentGroup.g; CBigNum h = params->serialNumberSoKCommitmentGroup.h; CHashWriter hasher(0,0); hasher << *params << commitmentToCoin.getCommitmentValue() << coin.getSerialNumber() << msghash; vector<CBigNum> r(params->zkp_iterations); vector<CBigNum> v_seed(params->zkp_iterations); vector<CBigNum> v_expanded(params->zkp_iterations); vector<CBigNum> c(params->zkp_iterations); for(uint32_t i=0; i < params->zkp_iterations; i++) { r[i] = CBigNum::randBignum(params->coinCommitmentGroup.groupOrder); //use a random 256 bit seed that expands to 1024 bit for v[i] while (true) { uint256 hashRand = CBigNum::randBignum(CBigNum(~uint256(0))).getuint256(); CBigNum bnExpanded = SeedTo1024(hashRand); if(bnExpanded > params->serialNumberSoKCommitmentGroup.groupOrder) continue; v_seed[i] = CBigNum(hashRand); v_expanded[i] = bnExpanded; break; } } for(uint32_t i=0; i < params->zkp_iterations; i++) { // compute g^{ {a^x b^r} h^v} mod p2 c[i] = challengeCalculation(coin.getSerialNumber(), r[i], v_expanded[i]); } // We can't hash data in parallel either // because OPENMP cannot not guarantee loops // execute in order. for(uint32_t i=0; i < params->zkp_iterations; i++) { hasher << c[i]; } this->hash = hasher.GetHash(); unsigned char *hashbytes = (unsigned char*) &hash; for(uint32_t i = 0; i < params->zkp_iterations; i++) { int bit = i % 8; int byte = i / 8; bool challenge_bit = ((hashbytes[byte] >> bit) & 0x01); if (challenge_bit) { s_notprime[i] = r[i]; sprime[i] = v_seed[i]; } else { s_notprime[i] = r[i] - coin.getRandomness(); sprime[i] = v_expanded[i] - (commitmentToCoin.getRandomness() * b.pow_mod(r[i] - coin.getRandomness(), params->serialNumberSoKCommitmentGroup.groupOrder)); } } }
CMainParams() { // The message start string is designed to be unlikely to occur in normal data. pchMessageStart[0] = 0x06; pchMessageStart[1] = 0x03; pchMessageStart[2] = 0x04; pchMessageStart[3] = 0x01; nDefaultPort = 2222; //Ring was forged in the second age nRPCPort = 2223; //Ring was forged in the second age. bnProofOfWorkLimit = CBigNum(~uint256(0) >> 20); nSubsidyHalvingInterval = 500000; // Build the genesis block. Note that the output of the genesis coinbase cannot // be spent as it did not originally exist in the database. const char* pszTimestamp = "Sauron says hello."; CTransaction txNew; txNew.vin.resize(1); 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 = 1 * COIN; txNew.vout[0].scriptPubKey = CScript() << ParseHex("") << OP_CHECKSIG; genesis.vtx.push_back(txNew); genesis.hashPrevBlock = 0; genesis.hashMerkleRoot = genesis.BuildMerkleTree(); genesis.nVersion = 1; genesis.nTime = 1386541846; genesis.nBits = 0x1e0fffff; genesis.nNonce = 0; //// debug print hashGenesisBlock = genesis.GetHash(); while (hashGenesisBlock > bnProofOfWorkLimit.getuint256()){ if (++genesis.nNonce==0) break; hashGenesisBlock = genesis.GetHash(); } printf("%s\n", hashGenesisBlock.ToString().c_str()); printf("%s\n", genesis.hashMerkleRoot.ToString().c_str()); printf("%x\n", bnProofOfWorkLimit.GetCompact()); genesis.print(); assert(hashGenesisBlock == uint256("0x")); assert(genesis.hashMerkleRoot == uint256("0x")); vSeeds.push_back(CDNSSeedData("someaddress.com or IP addy", "someaddress.com")); base58Prefixes[PUBKEY_ADDRESS] = 63; base58Prefixes[SCRIPT_ADDRESS] = 30; base58Prefixes[SECRET_KEY] = 224; // Convert the pnSeeds array into usable address objects. for (unsigned int i = 0; i < ARRAYLEN(pnSeed); i++) { // It'll only connect to one or two seed nodes because once it connects, // it'll get a pile of addresses with newer timestamps. // Seed nodes are given a random 'last seen time' const int64 nTwoDays = 2 * 24 * 60 * 60; struct in_addr ip; memcpy(&ip, &pnSeed[i], sizeof(ip)); CAddress addr(CService(ip, GetDefaultPort())); addr.nTime = GetTime() - GetRand(nTwoDays) - nTwoDays; vFixedSeeds.push_back(addr); } }
bool CastToBool(const valtype& vch) { return (CBigNum(vch) != bnZero); }