Check your pm for a python script

I know it's a long shot, but still: Any chance you ever signed a message to prove ownership of that address?

You can't do it in that short time, as you don't have the public key.

It's a good thing that you have end of WIF format data where the checksum is. You have to first Base58 decode the string (with corrupted part, or you can replace the corrupted part with zeros). Since you are doing it only once you can use this online tool:
https://www.browserling.com/tools/base58-decode

Once you have decoded number you can use the checksum to quickly check the possible missing values, if the checksum does not match you do not need the other calculations to get public key and check against it.
This is enormous speed-up, this is doable even on CPU, no need for GPU.

I doubt that you have some ready made tool for this second step, have to do some work yourself to code checking the missing values against the checksum. Good luck!


Edit:
Just tried it with some test values, you have to do Base58 Decode for all possible versions of missing values, not only once, string before corrupted characters stays the same but Base58 Encode changes all values after the corrupted place.

However, this is still much, much faster then generating Public key, doable on CPU for sure.

You can't do it in that short time, as you don't have the public key.

1 year ago, user PawGo calculated exactly your case (10 missing WIF characters) but with the public key in less than 11 minutes.


They started with less missing characters but then ...


Thread: Using Kangaroo for WIF solving http://bitcointalk.org/index.php?topic=5315607.0

---

Edit: PawGo posted

Normal Kangaroo yes, but I have already patched it for solving WIFs, custom stride is supported. Link in post above

Keep in mind that this method is significantly slower than to simply test each character permutation.
You see each character at the start of the string (from left) converts to a much bigger integer than any character from the end of the string. So even the difference between 1 char missing becomes huge.
Take the following example:
Ky**DfuvLpt8eSb8EQzhZwDCQeCaycKeAoxJMY8pfPZXmn3uB38R
Even though only 2 characters are missing the difference between Ky11Df... and KyzzDf... as integer is
While the permutations are only 3364.

Pollard's Kangaroo method also uses a start and end range. However, it does not support strides (AFAIK) because Pollard's Kangaroo algo is using it's own kind of stride while making the tame and wild kangaroos hop. There's no way to tell Kangaroo: "OK, there is a part of the private key at the end that's already known, don't search those bits". The consequence is that for this particular situation, Kangaroo will take longer to find the PK (way too long actually).

Bitcrack, on the other hand, lets us specify an arbitrarily large stride and it converts it to a 256-bit int. Since in this case, 80% of the private key is already known, we can make the stride equal to that huge PK chunk at the end and effectively, only search keys between Kw11111111...... and Kwzzzzzzzzzz.......


My hex for w1111111111 came from the following input: w1111111111JzXaqU2rcFSoaLaehAQHqoQX1cWCo92tAA3ihLJ7oQX1cWCo92tAA3ihLJ7 (I accidentally duplicated the last part).

Yeah you're right - my memory was a bit rusty. In any case just replace the -u flag with -c.

I simply converted the base58 of the lower characters to decimal (and hex). First I went to this page: https://www.dcode.fr/base-58-cipher

And then I pasted the characters after the lost 10 chars inside the page. Before the characters, I pated the 'w' (since you know you have that), followed the 10 characters lowest possible private keys that still base-58 encode into w........JzXaqU2rcFSoaLaehAQHqoQX1cWCo92tAA3ihLJ7 - replace the dots with 10 "1" (the number one) characters. Because 1 is the first digit of base8 number system. The resulting hex gives the starting range.

Then to get the end range, you repeat the process but instead of ten 1 characters, you insert 10 'z' characters (the highest character in base58 is lowercase 'z').

To get the stride, I simply converted the lower part of the base58 you had (the one after the dots).

To determine the start and end ranges and the stride, you only need part of the WIF, not the public address.

These steps will create a range and strie that is suitable to input inside Bitcrack.

No problem, because Bitcrack is more efficient than Kangaroo for your problem (also, Kangaroo will only work if you have the public key, not the address).



58**10 is a very large number, however to estimate the difficulty, you need the equivalent power in base 2, so what we do is we take the log2 of the result: log2(58**10). Then if gives us the difficulty in bits: such that 2**bits == 58**10 (here, bits equals 58.a_fractional_part).

Difficulty can also be written as "10 base 8 characters", but its common for programs to estimate it in terms of bits as well.

This will probably not take minutes unless you have a large GPU farm, but a few weeks is a more accurate estimate. Since Bitcrack can only talk to 1 GPU as far as I know.

We don't have an outgoing transaction, so we can't do it with pollard or kangaroo.

So that would be very easy. ~60 missing bits, we would have the private key within minutes.

If there is an outgoing transaction, then with the un/compressed public key and kangaroo or pollard, also possible.

See my answer on Jean Luc's Kangaroo thread:


Note: it's important to place your public address at the end of the command (after the stride), although I did not write that in the other post.

Do you have the compressed/uncompressed public key or outgoing transactions from that address?

Is the paper missing after Kw or is there enough paper for some letters, so that the chemical analysis would help you to recover some more characters to make the calculation easier?

For example:
Kw**********jcQ...

** -> paper / chemical analysis / recover characters
****** -> hole / no paper

-> so you would have 6 missing characters

do you have the seed phrase or only saved the PK?