Proof of work market: I will select the lowest MD5 hash submitted
11
Ṁ780Ṁ1.8kresolved Jun 26
100%71%
proofofworkmarket<<<<F0C":00000000005e73c35e8a93e819f543a5
0.7%Other
0.0%
proofofworkmarket2:0cc1e06a125489f066517540476e7da9
26%
ANTE
0.0%
proofofworkmarket2623326:000000d15a5e3bcd35f21ee4a730d92e
0.0%
proofofworkmarketd56f496cddd2b923ef52ae96b0ba2cd0:00000002eed77ddf3a95d78c4439ddaa
0.0%
proofofworkmarket2392249cd1c9d328fb674f087b2b6747e:00000001e26934ba7496eec4ef39d55a
0.0%
proofofworkmarket92696743373:00000001702574cf63c6084281d25b9c
0.0%
proofofworkmarket6194463258:0000000007b6fac39fc3f008117f6670
1.2%
proofofworkmarket6194463258:0000000007b6fac39fc3f008117f6670
0.0%
proofofworkmarket___b92f22b309:00000000060be6c15687feb3981f3520
0.0%
proofofworkmarket___d2ab4684cb:00000000051d612ab997a059aa1e5cc6
0.0%
proofofworkmarket6efa29ef0f7daa86a4776a0e5fef2720:0000000002c7144b4697621bfd96c7bf
0.0%
proofofworkmarket___d8d653a408:0000000001e50dac3f573c3ccdd06287
0.0%
proofofworkmarket...3782778b7e:00000000015a30589dec32973dd1a158
0.9%
proofofworkmarket5234262oglK62MMPJzYCbHHAnl:0000000000ea92d7cad6c5eadb757b54
Submit answers in the format: "proofofworkmarket[<insert anything here>]":<MD5 hash of the string between quotes>.
I will select as correct the answer with the lowest hash value, where it is a valid md5 hash of the string between the quotes. The string must start with the words "proofofworkmarket", and can contain anything after that, but should be all ascii characters.
Jun 21, 12:05am: Provided an example valid answer. I will not submit any more valid answers.
This question is managed and resolved by Manifold.
Market context
Get 
1,000 to start trading!
1,000🏅 Top traders
| # | Trader | Total profit |
|---|---|---|
| 1 | Ṁ367 | |
| 2 | Ṁ240 | |
| 3 | Ṁ70 | |
| 4 | Ṁ39 | |
| 5 | Ṁ31 |
Sort by:
Congrats @joy_void_joy. Not sure what, if anything, this market has shown. Although I expected everyone to hold back their answers until the last moment in order not to reveal their cards - but I guess it's just more fun to just compete openly, and after all it's all about fun.
@Undox Actually, I got really lucky, the hash was found after like ~10 minutes of running the script (which explains why it's so short too). I let it run for one hour more just in case I found better
If anyone is interested I mined with: https://github.com/Zumili/find-extreme-hashes
The exact command was:
``python find-extreme-hashes.py -u proofofworkmarket -w [number of cores] -m md5 -o manifold -b 1 -n -c 8 --shuffle``
Very efficient, uses all cores
@JoyVoid I did CPU mining with a small Rust program. I would have tried GPU or FPGA mining if I had a good GPU or FPGA.
@ManifoldMarketsUser well, I wasn't really ready for a duplicate from the same user. In this case i guess I'd resolve to both, otherwise just to the first (chronologically) instance.
@ManifoldMarketsUser yes, as I understand it, all money bet in the market goes to the winner (minus fees), and this is just an option that will not be the winner. Nothing special about it tho, i could just as well bet on a different known loser.
For those wondering about how reasonable it is to use md5 in proof-of-work contexts, considering that it's very cryptographically broken: https://crypto.stackexchange.com/questions/29610/is-it-safe-to-use-md5-in-a-proof-of-work-system
> Currently, it is probably safe. There are preimage attacks on MD5 but they are only slightly better than brute force. With a proof of work that only requires the initial bits of the hash to match it would likely be easier to use brute force than try to apply any attacks on it.
>
> However, I cannot see a good reason you would do that instead of using a more secure hash function, like SHA-256 – or SHA-256/128 if the output length must match.
@jack I am of course aware of that - but if someone wants to utilize a complicated attack to extract a few hundred mana, they are more than welcome to :)
I am currently mining with the crude JavaScript script below in Node.js. Most of it from StackOverflow :-). If you want to, run this too (it will look for different hashes for you due to the random statement in the code), we can be like a "mining pool".
let best = "9";
let prev = '' + Math.random();
console.log('Seed: ' + prev);
while (true) {
const currInput = prev;
const curr = md5("proofofworkmarket" + currInput);
if (curr < best) {
best = curr;
bestinput = currInput;
console.log(bestinput + " -> " + best);
}
prev = curr;
}
document.getElementById("progress").innerText = 'stopped'
// FROM : https://stackoverflow.com/questions/1655769/fastest-md5-implementation-in-javascript
// A formatted version of a popular md5 implementation.
// Original copyright (c) Paul Johnston & Greg Holt.
// The function itself is now 42 lines long.
function md5(inputString) {
var hc = "0123456789abcdef";
function rh(n) {
var j,
s = "";
for (j = 0; j <= 3; j++)
s +=
hc.charAt((n >> (j * 8 + 4)) & 0x0f) + hc.charAt((n >> (j * 8)) & 0x0f);
return s;
}
function ad(x, y) {
var l = (x & 0xffff) + (y & 0xffff);
var m = (x >> 16) + (y >> 16) + (l >> 16);
return (m << 16) | (l & 0xffff);
}
function rl(n, c) {
return (n << c) | (n >>> (32 - c));
}
function cm(q, a, b, x, s, t) {
return ad(rl(ad(ad(a, q), ad(x, t)), s), b);
}
function ff(a, b, c, d, x, s, t) {
return cm((b & c) | (~b & d), a, b, x, s, t);
}
function gg(a, b, c, d, x, s, t) {
return cm((b & d) | (c & ~d), a, b, x, s, t);
}
function hh(a, b, c, d, x, s, t) {
return cm(b ^ c ^ d, a, b, x, s, t);
}
function ii(a, b, c, d, x, s, t) {
return cm(c ^ (b | ~d), a, b, x, s, t);
}
function sb(x) {
var i;
var nblk = ((x.length + 8) >> 6) + 1;
var blks = new Array(nblk * 16);
for (i = 0; i < nblk * 16; i++) blks[i] = 0;
for (i = 0; i < x.length; i++)
blks[i >> 2] |= x.charCodeAt(i) << ((i % 4) * 8);
blks[i >> 2] |= 0x80 << ((i % 4) * 8);
blks[nblk * 16 - 2] = x.length * 8;
return blks;
}
var i,
x = sb(inputString),
a = 1732584193,
b = -271733879,
c = -1732584194,
d = 271733878,
olda,
oldb,
oldc,
oldd;
for (i = 0; i < x.length; i += 16) {
olda = a;
oldb = b;
oldc = c;
oldd = d;
a = ff(a, b, c, d, x[i + 0], 7, -680876936);
d = ff(d, a, b, c, x[i + 1], 12, -389564586);
c = ff(c, d, a, b, x[i + 2], 17, 606105819);
b = ff(b, c, d, a, x[i + 3], 22, -1044525330);
a = ff(a, b, c, d, x[i + 4], 7, -176418897);
d = ff(d, a, b, c, x[i + 5], 12, 1200080426);
c = ff(c, d, a, b, x[i + 6], 17, -1473231341);
b = ff(b, c, d, a, x[i + 7], 22, -45705983);
a = ff(a, b, c, d, x[i + 8], 7, 1770035416);
d = ff(d, a, b, c, x[i + 9], 12, -1958414417);
c = ff(c, d, a, b, x[i + 10], 17, -42063);
b = ff(b, c, d, a, x[i + 11], 22, -1990404162);
a = ff(a, b, c, d, x[i + 12], 7, 1804603682);
d = ff(d, a, b, c, x[i + 13], 12, -40341101);
c = ff(c, d, a, b, x[i + 14], 17, -1502002290);
b = ff(b, c, d, a, x[i + 15], 22, 1236535329);
a = gg(a, b, c, d, x[i + 1], 5, -165796510);
d = gg(d, a, b, c, x[i + 6], 9, -1069501632);
c = gg(c, d, a, b, x[i + 11], 14, 643717713);
b = gg(b, c, d, a, x[i + 0], 20, -373897302);
a = gg(a, b, c, d, x[i + 5], 5, -701558691);
d = gg(d, a, b, c, x[i + 10], 9, 38016083);
c = gg(c, d, a, b, x[i + 15], 14, -660478335);
b = gg(b, c, d, a, x[i + 4], 20, -405537848);
a = gg(a, b, c, d, x[i + 9], 5, 568446438);
d = gg(d, a, b, c, x[i + 14], 9, -1019803690);
c = gg(c, d, a, b, x[i + 3], 14, -187363961);
b = gg(b, c, d, a, x[i + 8], 20, 1163531501);
a = gg(a, b, c, d, x[i + 13], 5, -1444681467);
d = gg(d, a, b, c, x[i + 2], 9, -51403784);
c = gg(c, d, a, b, x[i + 7], 14, 1735328473);
b = gg(b, c, d, a, x[i + 12], 20, -1926607734);
a = hh(a, b, c, d, x[i + 5], 4, -378558);
d = hh(d, a, b, c, x[i + 8], 11, -2022574463);
c = hh(c, d, a, b, x[i + 11], 16, 1839030562);
b = hh(b, c, d, a, x[i + 14], 23, -35309556);
a = hh(a, b, c, d, x[i + 1], 4, -1530992060);
d = hh(d, a, b, c, x[i + 4], 11, 1272893353);
c = hh(c, d, a, b, x[i + 7], 16, -155497632);
b = hh(b, c, d, a, x[i + 10], 23, -1094730640);
a = hh(a, b, c, d, x[i + 13], 4, 681279174);
d = hh(d, a, b, c, x[i + 0], 11, -358537222);
c = hh(c, d, a, b, x[i + 3], 16, -722521979);
b = hh(b, c, d, a, x[i + 6], 23, 76029189);
a = hh(a, b, c, d, x[i + 9], 4, -640364487);
d = hh(d, a, b, c, x[i + 12], 11, -421815835);
c = hh(c, d, a, b, x[i + 15], 16, 530742520);
b = hh(b, c, d, a, x[i + 2], 23, -995338651);
a = ii(a, b, c, d, x[i + 0], 6, -198630844);
d = ii(d, a, b, c, x[i + 7], 10, 1126891415);
c = ii(c, d, a, b, x[i + 14], 15, -1416354905);
b = ii(b, c, d, a, x[i + 5], 21, -57434055);
a = ii(a, b, c, d, x[i + 12], 6, 1700485571);
d = ii(d, a, b, c, x[i + 3], 10, -1894986606);
c = ii(c, d, a, b, x[i + 10], 15, -1051523);
b = ii(b, c, d, a, x[i + 1], 21, -2054922799);
a = ii(a, b, c, d, x[i + 8], 6, 1873313359);
d = ii(d, a, b, c, x[i + 15], 10, -30611744);
c = ii(c, d, a, b, x[i + 6], 15, -1560198380);
b = ii(b, c, d, a, x[i + 13], 21, 1309151649);
a = ii(a, b, c, d, x[i + 4], 6, -145523070);
d = ii(d, a, b, c, x[i + 11], 10, -1120210379);
c = ii(c, d, a, b, x[i + 2], 15, 718787259);
b = ii(b, c, d, a, x[i + 9], 21, -343485551);
a = ad(a, olda);
b = ad(b, oldb);
c = ad(c, oldc);
d = ad(d, oldd);
}
return rh(a) + rh(b) + rh(c) + rh(d);
}