17:04:21

getblockhash 1


17:04:21

5f0d273c328c7c3506a4a635f4ddeb294f742eec5bf2b829b3901e53ea8965f2


17:04:24

getyespowerpowhash 1


17:04:24

0008a598f6c4e50603a12af8cfc720ea670a5e84d9e8fb228e6ffe775c6269ac


17:04:30

getargon2idpowhash 1


17:04:30

0011dc045e2c60ca760860dedffc332a60d54d738622e21b6364d9ac1d1f3f5e

static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
{
    // Check proof of work's matches claimed amount (dual pow logic)
    bool powResult1 = fCheckPOW ? CheckProofOfWork(block.GetYespowerPoWHash(), block.nBits, consensusParams) : true;
    bool powResult2 = fCheckPOW ? CheckProofOfWork(block.GetArgon2idPoWHash(), block.nBits, consensusParams) : true;

    // Checking if both POW's are valid
    if (!powResult1 || !powResult2) {
        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work's failed");
    }

    return true;
}

/* Yespower */
uint256 CBlockHeader::GetYespowerPoWHash() const
{
    static const yespower_params_t yespower_1_0_dpowcoin = {
        .version = YESPOWER_1_0,
        .N = 2048,
        .r = 8,
        .pers = (const uint8_t *)"One POW? Why not two? 17/04/2024",
        .perslen = 32
    };
    uint256 hash;
    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
    ss << *this;
    if (yespower_tls((const uint8_t *)&ss[0], ss.size(), &yespower_1_0_dpowcoin, (yespower_binary_t *)&hash)) {
        tfm::format(std::cerr, "Error: CBlockHeader::GetYespowerPoWHash(): failed to compute PoW hash (out of memory?)\n");
        exit(1);
    }
    return hash;
}

// CBlockHeader::GetArgon2idPoWHash() instance
// -> Serialize Block Header using CDataStream
// -> Compute SHA-512 hash of serialized data (Two Rounds)
// -> Use the computed hash as the salt for argon2id_hash_raw function for the first round
// -> Call argon2id_hash_raw function for the first round using the serialized data as password and SHA-512 hash as salt
// -> Use the hash obtained from the first round as the salt for the second round
// -> Call argon2id_hash_raw function for the second round using the serialized data as password and the hash from the first round as salt
// -> Return the hash computed in the second round (hash2)

uint256 CBlockHeader::GetArgon2idPoWHash() const
{
    uint256 hash;
    uint256 hash2;
    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
    ss << *this;
   
    // Hashing the data using SHA-512 (two rounds)
    std::vector<unsigned char> salt_sha512(CSHA512::OUTPUT_SIZE);
    CSHA512 sha512;
    sha512.Write((unsigned char*)&ss[0], ss.size()).Finalize(salt_sha512.data());
    sha512.Reset().Write(salt_sha512.data(), salt_sha512.size()).Finalize(salt_sha512.data());
   
    // Preparing data for hashing
    const void* pwd = &ss[0];
    size_t pwdlen = ss.size();
    const void* salt = salt_sha512.data();
    size_t saltlen = salt_sha512.size();
   
    // Calling the argon2id_hash_raw function for the first round
    int rc = argon2id_hash_raw(2, 4096, 2, pwd, pwdlen, salt, saltlen, &hash, 32);
    if (rc != ARGON2_OK) {
        printf("Error: Failed to compute Argon2id hash for the first round\n");
        exit(1);
    }
   
    // Using the hash from the first round as the salt for the second round
    salt = &hash;
    saltlen = 32;
   
    // Calling the argon2id_hash_raw function for the second round
    rc = argon2id_hash_raw(2, 32768, 2, pwd, pwdlen, salt, saltlen, &hash2, 32);
    if (rc != ARGON2_OK) {
        printf("Error: Failed to compute Argon2id hash for the second round\n");
        exit(1);
    }

    // Return the result of the second round of Argon2id
    return hash2;
}

Based at Bitcoin 26.1 final stable release.

Coin Name   Dpowcoin

Short Name   DPC

Block Time   5m or 300s

Diff Retargeting   LWMA3 with N 576

Reward   50 coins

Subsidy Halving Interval   Every 420 000 blocks

Proof Type   Dual POW ( not multi pow!)

Algo   Dual POW - by Yespower and Argon2id 0x13 + SHA512

POW check like at LTC   Using sha256d in headers indexing

Legacy Address Prefix   P - 55 - 0x37

P2SH-SegWit Address Prefix   C - 28 - 0x1c

Bech32-SegWit Prefix   dpc1

Default p2p port   42003

Default rpc port   42002

powLimit   001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

BIPs activated   Block 2

Network Magic   0xf29f4afb

bip324 Salt   dpowcoin_v2_shared_secret

COINBASE MATURITY   100

MAX SUPPLY   42 000 000

Pre Mine   None if not count 3 blocks for activate "BIP" rules.

Dev Fees   None

generatetoaddress nblocks "address" ( maxtries )

generatetoaddress 10000 "Myaddress" -1

static bool CheckBlockHeader(const CBlockHeader& block, BlockValidationState& state, const Consensus::Params& consensusParams, bool fCheckPOW = true)
{
    // Check POW's
    bool powResult1 = fCheckPOW ? CheckProofOfWork(block.GetArgon2idPoWHash(), block.nBits, consensusParams) : true;
    bool powResult2 = fCheckPOW ? CheckProofOfWork(block.GetSomeOtherPOW(), block.nBits, consensusParams) : true;

    // Checking if both POW's are valid
    if (!powResult1 || !powResult2) {
        return state.Invalid(BlockValidationResult::BLOCK_INVALID_HEADER, "high-hash", "proof of work failed");
    }

    return true;
}

uint256 CBlockHeader::GetArgon2idPoWHash() const
{
    uint256 hash;
    uint256 hash2;
    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
    ss << *this;
    
    // Hashing the data using SHA-512 (two rounds)
    std::vector<unsigned char> salt_sha512(CSHA512::OUTPUT_SIZE);
    CSHA512().Write((unsigned char*)&ss[0], ss.size()).Finalize(salt_sha512.data());
    CSHA512().Write(salt_sha512.data(), salt_sha512.size()).Finalize(salt_sha512.data());
    
    // Preparing data for hashing
    const void* pwd = &ss[0];
    size_t pwdlen = ss.size();
    const void* salt = salt_sha512.data();
    size_t saltlen = salt_sha512.size();
    
    // Calling the argon2id_hash_raw function for the first round
    int rc = argon2id_hash_raw(2, 262144, 4, pwd, pwdlen, salt, saltlen, &hash, 32);
    if (rc != ARGON2_OK) {
        printf("Error: Failed to compute Argon2id hash\n");
        exit(1);
    }
    
    // Hashing the result of the first round using SHA-512 (two rounds)
    std::vector<unsigned char> salt_sha512_round2(CSHA512::OUTPUT_SIZE);
    CSHA512().Write((unsigned char*)&hash, 32).Finalize(salt_sha512_round2.data());
    CSHA512().Write(salt_sha512_round2.data(), salt_sha512_round2.size()).Finalize(salt_sha512_round2.data());
    
    // Calling the argon2id_hash_raw function for the second round
    rc = argon2id_hash_raw(2, 524288, 4, &hash, 32, salt_sha512_round2.data(), salt_sha512_round2.size(), &hash2, 32);
    if (rc != ARGON2_OK) {
        printf("Error: Failed to compute Argon2id hash for the second round\n");
        exit(1);
    }
    
    return hash2;
}