ePL Bitcoin Mining

/******************************************************************************
 *
 * SHA256 Example
 *
 * Name:    SHA256_BTC.epl
 * Desc:    Demo Of SHA256 Algo Using BTC 80 Byte Header and SHA256d 
 *
 * Memory Map:
 *   Round Number:          m[ 10]
 *   Padded Block Header:   u[  0] - u[ 32]
 *   Hash 1 (Midstate):        u[ 40] - u[ 47]
 *   Hash 2 (Final):        u[ 50] - u[ 57]
 *   K:                     u[100] - u[163]
 *   H:                     u[200] - u[208]
 *   w:                     u[300] - u[363]
 *   Temp Variables:        u[400] - u[415]
 *   a-h:                   u[500] - u[507]
 *
 *****************************************************************************/

array_uint 1000;

// s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3)
// s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor (w[i-2] rightshift 10)
// w[i] := w[i-16] + s0 + w[i-7] + s1
function init_w {

    // w[i-15]
    u[400] = u[301 + u[99]];

    // w[i-2]
    u[401] = u[314 + u[99]];

    // s0
    u[402] = ((u[400] >>> 7) ^ (u[400] >>> 18) ^ (u[400] >> 3));

    // s1
    u[403] = ((u[401] >>> 17) ^ (u[401] >>> 19) ^ (u[401] >> 10));

    // w[i]
    u[316 + u[99]] = u[300 + u[99]] + u[402] + u[309 + u[99]] + u[403];
}

// S1 := (e rightrotate 6) xor (e rightrotate 11) xor (e rightrotate 25)
// ch := (e and f) xor ((not e) and g)
// temp1 := h + S1 + ch + k[i] + w[i]
// S0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22)
// maj := (a and b) xor (a and c) xor (b and c)
// temp2 := S0 + maj
function compress {

    // S1
    u[410] = ((u[504] >>> 6) ^ (u[504] >>> 11) ^ (u[504] >>> 25));

    // ch
    u[411] = ((u[504] & u[505]) ^ (~u[504] & u[506]));

    // temp1
    u[412] = u[507] + u[410] + u[411] + u[100 + u[99]] + u[300 + u[99]];

    // S0
    u[413] = ((u[500] >>> 2) ^ (u[500] >>> 13) ^ (u[500] >>> 22));

    // maj
    u[414] = ((u[500] & u[501]) ^ (u[500] & u[502]) ^ (u[501] & u[502]));

    // temp2
    u[415] = u[413] + u[414];

    // Update a-h
    u[507] = u[506];
    u[506] = u[505];
    u[505] = u[504];
    u[504] = u[503] + u[412];
    u[503] = u[502];
    u[502] = u[501];
    u[501] = u[500];
    u[500] = u[412] + u[415];
}

function sha256 {

    // Initialize w[16] - w[63] (Use u[99] As Counter)
    repeat(u[99], 48, 48) {
        init_w();
    }

    // Initialize a - h
    u[500] = u[200];    // a
    u[501] = u[201];    // b
    u[502] = u[202];    // c
    u[503] = u[203];    // d
    u[504] = u[204];    // e
    u[505] = u[205];    // f
    u[506] = u[206];    // g
    u[507] = u[207];    // h

    // Compress Current Chunk
    repeat(u[99], 64, 64) {
        compress();
    }

    // Add Compressed Chunk To Hash Value
    u[200] += u[500];
    u[201] += u[501];
    u[202] += u[502];
    u[203] += u[503];
    u[204] += u[504];
    u[205] += u[505];
    u[206] += u[506];
    u[207] += u[507];

}

function main {

    // In this example, the full SHA256d algo is needed to verify results.
    // Also, because the algo is small / fast enough (less than WCET = TBD);
    // the logic does not need to be broken into pieces and the complete logic
    // will fit in the verify function.
    // Therfore, the only logic needed in the main function is to call the
    // verify function.

    verify();
}

function verify {

    init_K();

    // Input Data To Be Hashed
    u[0] = 0x01000000;
    u[1] = 0x00000000;
    u[2] = 0x00000000;
    u[3] = 0x00000000;
    u[4] = 0x00000000;
    u[5] = 0x00000000;
    u[6] = 0x00000000;
    u[7] = 0x00000000;
    u[8] = 0x00000000;
    u[9] = 0x3BA3EDFD;
    u[10] = 0x7A7B12B2;
    u[11] = 0x7AC72C3E;
    u[12] = 0x67768F61;
    u[13] = 0x7FC81BC3;
    u[14] = 0x888A5132;
    u[15] = 0x3A9FB8AA;
    u[16] = 0x4B1E5E4A;
    u[17] = 0x29AB5F49;
    u[18] = 0xFFFF001D;
    u[19] = m[10];    // Nonce = Round Number
    u[20] = 0x80000000;
    u[21] = 0x00000000;
    u[22] = 0x00000000;
    u[23] = 0x00000000;
    u[24] = 0x00000000;
    u[25] = 0x00000000;
    u[26] = 0x00000000;
    u[27] = 0x00000000;
    u[28] = 0x00000000;
    u[29] = 0x00000000;
    u[30] = 0x00000000;
    u[31] = 0x00000280;

    // Reset H Each Round
    init_H();

    // Copy First 512 Bit Chunk To Be Hashed Into w[0] - w[15]
    u[300] = u[0];
    u[301] = u[1];
    u[302] = u[2];
    u[303] = u[3];
    u[304] = u[4];
    u[305] = u[5];
    u[306] = u[6];
    u[307] = u[7];
    u[308] = u[8];
    u[309] = u[9];
    u[310] = u[10];
    u[311] = u[11];
    u[312] = u[12];
    u[313] = u[13];
    u[314] = u[14];
    u[315] = u[15];

    // Hash First 512 Bit Chunk
    sha256();

    // Copy Second 512 Bit Chunk To Be Hashed Into w[0] - w[15]
    u[300] = u[16];
    u[301] = u[17];
    u[302] = u[18];
    u[303] = u[19];
    u[304] = u[20];
    u[305] = u[21];
    u[306] = u[22];
    u[307] = u[23];
    u[308] = u[24];
    u[309] = u[25];
    u[310] = u[26];
    u[311] = u[27];
    u[312] = u[28];
    u[313] = u[29];
    u[314] = u[30];
    u[315] = u[31];

    // Hash Second 512 Bit Chunk
    sha256();

    // Store Hash1 (For Debugging Only)
    u[40] = u[200];
    u[41] = u[201];
    u[42] = u[202];
    u[43] = u[203];
    u[44] = u[204];
    u[45] = u[205];
    u[46] = u[206];
    u[47] = u[207];

    // Reset Hash
    init_H();

    // Copy Hash1 & Padding Into w[0] - w[15]
    u[300] = u[40];
    u[301] = u[41];
    u[302] = u[42];
    u[303] = u[43];
    u[304] = u[44];
    u[305] = u[45];
    u[306] = u[46];
    u[307] = u[47];
    u[308] = 0x80000000;
    u[309] = 0x00000000;
    u[310] = 0x00000000;
    u[311] = 0x00000000;
    u[312] = 0x00000000;
    u[313] = 0x00000000;
    u[314] = 0x00000000;
    u[315] = 0x00000100;

    // Hash Hash1
    sha256();

    // Store Hash2 (For Debugging Only)
    u[50] = u[200];
    u[51] = u[201];
    u[52] = u[202];
    u[53] = u[203];
    u[54] = u[204];
    u[55] = u[205];
    u[56] = u[206];
    u[57] = u[207];

    // Bounty Is Rewarded When h7 Of Hash2 Is Zero
    // For This Example h7 Equals Zero When u[19] = 0x1DAC2B7C;
    verify_bty (u[57] == 0)

    // POW Is Rewarded When The MD5 Hash Of h7, h6, h5 & h4 Is Less Than Target
    verify_pow (u[57], u[56], u[55], u[54])
}

function init_K {
    u[100] = 0x428a2f98;
    u[101] = 0x71374491;
    u[102] = 0xb5c0fbcf;
    u[103] = 0xe9b5dba5;
    u[104] = 0x3956c25b;
    u[105] = 0x59f111f1;
    u[106] = 0x923f82a4;
    u[107] = 0xab1c5ed5;
    u[108] = 0xd807aa98;
    u[109] = 0x12835b01;
    u[110] = 0x243185be;
    u[111] = 0x550c7dc3;
    u[112] = 0x72be5d74;
    u[113] = 0x80deb1fe;
    u[114] = 0x9bdc06a7;
    u[115] = 0xc19bf174;
    u[116] = 0xe49b69c1;
    u[117] = 0xefbe4786;
    u[118] = 0x0fc19dc6;
    u[119] = 0x240ca1cc;
    u[120] = 0x2de92c6f;
    u[121] = 0x4a7484aa;
    u[122] = 0x5cb0a9dc;
    u[123] = 0x76f988da;
    u[124] = 0x983e5152;
    u[125] = 0xa831c66d;
    u[126] = 0xb00327c8;
    u[127] = 0xbf597fc7;
    u[128] = 0xc6e00bf3;
    u[129] = 0xd5a79147;
    u[130] = 0x06ca6351;
    u[131] = 0x14292967;
    u[132] = 0x27b70a85;
    u[133] = 0x2e1b2138;
    u[134] = 0x4d2c6dfc;
    u[135] = 0x53380d13;
    u[136] = 0x650a7354;
    u[137] = 0x766a0abb;
    u[138] = 0x81c2c92e;
    u[139] = 0x92722c85;
    u[140] = 0xa2bfe8a1;
    u[141] = 0xa81a664b;
    u[142] = 0xc24b8b70;
    u[143] = 0xc76c51a3;
    u[144] = 0xd192e819;
    u[145] = 0xd6990624;
    u[146] = 0xf40e3585;
    u[147] = 0x106aa070;
    u[148] = 0x19a4c116;
    u[149] = 0x1e376c08;
    u[150] = 0x2748774c;
    u[151] = 0x34b0bcb5;
    u[152] = 0x391c0cb3;
    u[153] = 0x4ed8aa4a;
    u[154] = 0x5b9cca4f;
    u[155] = 0x682e6ff3;
    u[156] = 0x748f82ee;
    u[157] = 0x78a5636f;
    u[158] = 0x84c87814;
    u[159] = 0x8cc70208;
    u[160] = 0x90befffa;
    u[161] = 0xa4506ceb;
    u[162] = 0xbef9a3f7;
    u[163] = 0xc67178f2;
}

function init_H {
    u[200] = 0x6a09e667;
    u[201] = 0xbb67ae85;
    u[202] = 0x3c6ef372;
    u[203] = 0xa54ff53a;
    u[204] = 0x510e527f;
    u[205] = 0x9b05688c;
    u[206] = 0x1f83d9ab;
    u[207] = 0x5be0cd19;
}