Engineering

“Freedom and accountability are two sides of the same coin.” ― Frédéric Laloux

VCoin data

Name

Vcoin

Symbol

VCN

Algo

SHA2-256

Launch date

13th May 2015

Derivation (clone parent)

Zetacoin, a fork of Bitcoin 0.8.2

Public code repository (launch)

https://github.com/vcoindev/vcoin

Public code repository (current)

https://github.com/vcoin-project/vcoincore

DOACC URI

doacc:D4b7a38bb-5765-4e3c-8197-1d430f977eb7

VCoin specifications

Total coins

1000000000 VCN

Block reward

50 VCN

Halving

100,000 blocks

Retarget time

40 blocks

Port

5530

RPCPort

5531

Halving schedule chart

Initial block reward 50 VCN.

Halving every 100,000 blocks (~35 days).

Minimum subsidy 1 VCN, applicable after block 600,000 (7th Dec 2015)

Mainnet Chain parameters

CMainParams() {
    strNetworkID = "main";
    consensus.nSubsidyHalvingInterval = 100000;
    consensus.nMajorityEnforceBlockUpgrade = 750;
    consensus.nMajorityRejectBlockOutdated = 950;
    consensus.nMajorityWindow = 1000;
    consensus.powLimit = uint256S("0x00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~arith_uint256(0) >> 20
    consensus.nPowTargetTimespan = 1200; // 20 minutes
    consensus.nPowTargetSpacing = 30; // 30 seconds
    consensus.fPowAllowMinDifficultyBlocks = false;
    /**
     * 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
     * a large 32-bit integer with any alignment.
     */
    pchMessageStart[0] = 0x05;
    pchMessageStart[1] = 0x05;
    pchMessageStart[2] = 0xb5;
    pchMessageStart[3] = 0x05;
    vAlertPubKey = ParseHex(
        "0x04ddf6acee2cdba487e3bb2ec67ba96abd5bcc06ab62e79d00f745d9021d38b3" + \
        "739b2001bfc13055150047bd6b6a958e797be065fe05c9a8c1486605c169c5a12e");
    nDefaultPort = 5530;
    nPruneAfterHeight = 100000;

    genesis = CreateGenesisBlock(1431517588, 1486592, 0x1e0fffff, 1, 1 * COIN);
    consensus.hashGenesisBlock = genesis.GetHash();
    assert(consensus.hashGenesisBlock == uint256S("0x00000b7e804f0de87e7752550ff04d7686a4599509897feefd7f03904eb45633"));
    assert(genesis.hashMerkleRoot == uint256S("0x1576ef41775095b26a8f8f2bb65b693ec12230608a425aa84ee462381cae00e6"));

    vSeeds.push_back(CDNSSeedData("Minkiz", "minkiz.co"));

    base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,70);
    base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,30);
    base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,224);
    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> >();
    /*
    base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x88)(0xB0)(0x1E); // 'xpub'
    base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x88)(0xA0)(0xE4); // 'xpriv'
    base58Prefixes[EXT_COIN_TYPE]  = boost::assign::list_of(0x80000037); // BIP44 coin type is '37'
    */

    vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_main, pnSeed6_main + ARRAYLEN(pnSeed6_main));

    fMiningRequiresPeers = true;
    fDefaultConsistencyChecks = false;
    fRequireStandard = true;
    fMineBlocksOnDemand = false;
    fTestnetToBeDeprecatedFieldRPC = false;
    checkpointData = (CCheckpointData) {
        boost::assign::map_list_of
        ( 0, uint256S("0x00000b7e804f0de87e7752550ff04d7686a4599509897feefd7f03904eb45633")),
          1431517588, // * UNIX timestamp of last checkpoint block
          0,          // * total number of transactions between genesis and last checkpoint
                      //   (the tx=... number in the SetBestChain debug.log lines)
          2880        // * estimated number of transactions per day after checkpoint
    };
}

Testnet Chain parameters

CTestNetParams() {
    strNetworkID = "test";
    consensus.nSubsidyHalvingInterval = 100000;
    consensus.nMajorityEnforceBlockUpgrade = 51;
    consensus.nMajorityRejectBlockOutdated = 75;
    consensus.nMajorityWindow = 100;
    consensus.powLimit = uint256S("0x00000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); // ~arith_uint256(0) >> 20
    consensus.nPowTargetTimespan = 1200; // 20 minutes
    consensus.nPowTargetSpacing = 30; // 30 seconds
    consensus.fPowAllowMinDifficultyBlocks = true;
    pchMessageStart[0] = 0x01;
    pchMessageStart[1] = 0xfe;
    pchMessageStart[2] = 0xfe;
    pchMessageStart[3] = 0x05;
    nDefaultPort = 55534;
    nPruneAfterHeight = 1000;

    genesis = CreateGenesisBlock(1441062000, 1173545, 0x1e0fffff, 1, 1 * COIN);
    consensus.hashGenesisBlock = genesis.GetHash();

    assert(consensus.hashGenesisBlock == uint256S("0x000007e14c52364cee2d4d9483541d473e3e73c896df75882273b91313b44816"));
    assert(genesis.hashMerkleRoot == uint256S("0x1576ef41775095b26a8f8f2bb65b693ec12230608a425aa84ee462381cae00e6"));

    vFixedSeeds.clear();
    vSeeds.clear();
    vSeeds.push_back(CDNSSeedData("MinkizT", "minkiz.co"));

    base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,127);
    base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,30);
    base58Prefixes[SECRET_KEY] =     std::vector<unsigned char>(1,255);
    base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
    base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
    /*
    base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x81)(0xCF); // 'tpub'
    base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x80)(0x94); // 'tpriv'
    base58Prefixes[EXT_COIN_TYPE]  = boost::assign::list_of(0x80000037); // BIP44 coin type is '37'
    */

    vFixedSeeds = std::vector<SeedSpec6>(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test));

    fMiningRequiresPeers = false;
    fDefaultConsistencyChecks = false;
    fRequireStandard = false;
    fMineBlocksOnDemand = false;
    fTestnetToBeDeprecatedFieldRPC = true;

    checkpointData = (CCheckpointData) {
        boost::assign::map_list_of
        ( 0, uint256S("0x000007e14c52364cee2d4d9483541d473e3e73c896df75882273b91313b44816")),
        1374901773,
        0,
        2880
    };
}

Regtestnet Chain parameters

CRegTestParams() {
    strNetworkID = "regtest";
    consensus.nSubsidyHalvingInterval = 150;
    consensus.nMajorityEnforceBlockUpgrade = 750;
    consensus.nMajorityRejectBlockOutdated = 950;
    consensus.nMajorityWindow = 1000;
    consensus.powLimit = uint256S("7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
    consensus.nPowTargetTimespan = 1200; // 20 minutes
    consensus.nPowTargetSpacing = 30; // 30 seconds
    consensus.fPowAllowMinDifficultyBlocks = true;

    pchMessageStart[0] = 0xfa;
    pchMessageStart[1] = 0x0f;
    pchMessageStart[2] = 0xa5;
    pchMessageStart[3] = 0x5a;
    nDefaultPort = 56534;
    nPruneAfterHeight = 1000;

    genesis = CreateGenesisBlock(1296688602, 3, 0x207fffff, 1, 1 * COIN);
    consensus.hashGenesisBlock = genesis.GetHash();
    /*
    assert(consensus.hashGenesisBlock == uint256S("0x0"));
    assert(genesis.hashMerkleRoot == uint256S("0x0"));
    LogPrintf("regtest: %s\n", consensus.hashGenesisBlock.ToString().c_str());
    LogPrintf("regtest: %s\n", genesis.hashMerkleRoot.ToString().c_str());
    LogPrintf("regtest: %x\n", consensus.powLimit.ToString().c_str());
    */
    vFixedSeeds.clear(); //! Regtest mode doesn't have any fixed seeds.
    vSeeds.clear();  //! Regtest mode doesn't have any DNS seeds.

    fMiningRequiresPeers = false;
    fDefaultConsistencyChecks = true;
    fRequireStandard = false;
    fMineBlocksOnDemand = true;
    fTestnetToBeDeprecatedFieldRPC = false;

    base58Prefixes[PUBKEY_ADDRESS] = std::vector<unsigned char>(1,110);
    base58Prefixes[SCRIPT_ADDRESS] = std::vector<unsigned char>(1,30);
    base58Prefixes[SECRET_KEY]     = std::vector<unsigned char>(1,238);
    base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x87)(0xCF).convert_to_container<std::vector<unsigned char> >();
    base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x83)(0x94).convert_to_container<std::vector<unsigned char> >();
    /*
    base58Prefixes[EXT_PUBLIC_KEY] = boost::assign::list_of(0x04)(0x35)(0x81)(0xCF); // 'tpub'
    base58Prefixes[EXT_SECRET_KEY] = boost::assign::list_of(0x04)(0x35)(0x80)(0x94); // 'tpriv'
    base58Prefixes[EXT_COIN_TYPE]  = boost::assign::list_of(0x80000037); // BIP44 coin type is '37'
    */
    checkpointData = (CCheckpointData){
        boost::assign::map_list_of
        ( 0, uint256S("0x0")),
        0,
        0,
        0
    };
}
Do something