My understanding is there is a bit of a trade off here.
When there is no spend transaction the search method is:
Next Private Key -> Public Key -> Hash -> Bitcoin Address -> Compare Bitcoin Address, repeat until found
Note that due to the hashing functions used the Bitcoin Address is expected within a private key range of only 2160
When there is a spend transaction the search method is:
Next Private Key -> Public Key -> Compare Public Key, repeat until found
Note that the private key range in this case is the full 2256 but there are ways to speed up the process
So, I think full entropy 256 bit private keys are still safe even with multiple spend transactions, but they may be less safe than a 160 bit Bitcoin address from a full entropy 256 bit private key with no spend transactions.
Even better yet is a longer full 256 bit Bitcoin address based on a full entropy 256 bit private key with no spend transactions.
I understand but why can't a HBM2 16GB GPU do this faster than a system with a fast CPU + loads of system RAM.
I am not too technical on the details here but I understand that if you know the private key you can easily compute the public key, but not the other way around.
So since the search space is small, basically most of the private key starts with 0's then you can easily start a range at the small private keys basically something like " 000000000000000000000000000000000000000000000001A838B13505B26867 "
So the GPU would take that and increment it and compute the public key very fast and just compare it to the public key with the funds inside it.
What you are describing is the "brute force" method which can be done even faster than you think.
Since the PublicKey = PrivateKey * G (where G is an agreed to point on the elliptic curve and * is the defined scalar multiplication operation over the finite field of points on the elliptic curve) you can do the following:
0) Initialize PrivateKey to the start of the range you are interested in
1) Calculate the first PublicKey = PrivateKey * G
2) Compare the PublicKey to the target PublicKey, if they match then you are done and PrivateKey is the private key you are looking for
3) PrivateKey = PrivateKey + 1
4) PublicKey =
PublicKey + G (instead of PublicKey = PrivateKey * G because adding the point G to the current PublicKey point is faster than calculating the PublicKey point from PublicKey = PrivateKey * G "from scratch" every time through the loop)
5) Goto step 2)
However, people that are doing this search are not using this "brute force" method. They are using a much faster method. This much faster method requires a lot of RAM. This faster method is described in detail in a very large post withing the last few pages of this thread. Check it out.