Bitcoin Forum

Hey guys,

Looking to see if anyone can tell me how to modify the Vanitygen code so that it will start searching at the same point every time and not jump around to another random search position.

Thanks in advance :o)

Link to the sourcecode plz

Is it not enough to set the seed with the -s command parameter?

What are you trying to accomplish via starting at same point every time?
I ask because I may know of other code that would do what you are wanting.

Linear search is MUCH faster than random since with linear search you just do a single ECC addition for each new address instead of computing a full ECC private-> public multiplication for random search.

I don't think any of them work like that. That would be a silly implementation.
The starting point is always random, from that point the next try will increment the initially random private key (private key +=1 that is public key + G).

There isn't much to be "researched" if the starting point is always the same since we are talking about a completely random and unpredictable result (ie. hash) and setting a fixed starting point creates bias in the result. For example the key you chose may already start with the character(s) you are looking for in the address without needing to increment so your test will give you 0 tries to get the address which is a false conclusion.

Just remove the EC_KEY_generate_key function at line 129 (https://github.com/exploitagency/vanitygen-plus/blob/master/vanitygen.c#L129) and increment the private key, and then use something like BN_set_word to increment the private key int manually and then run EC_POINT_mul to multiply it by G.

Disclaimer: The linear search will probably be faster, I suspect that the key generation method is slow.

Vanitygen creates a PrivkeyPart if you use a Public Key with your search. That means you'll need the Private Key that belongs to the Public Key to convert the PrivkeyPart to the Private Key that beloings to the vanity address. Vanitygen doesn't know both parts (otherwise split key wouldn't be secure).
Maybe this helps:

No, when using split key, vanitygen doesn't know the final private key. The exact details of how it's done are lost on me though.

It's called split-key vanity address, short answer in the first sentence:

The other thing to keep in mind, you can edit code to make it start at same point/key, each and every time, but when using a GPU, normally the code works like this:

take GPU x and y grid size; let's say our is 10x10

then the program takes your range/keyspace, let's say we have a range of 1000000

now the program divides the range by the grid size, in our example:
grid is 10x10 = 100
range size = 1000000
so the program spreads out each GPU thread every 10000 keys/points, and then works incrementally.

Same is true for CPU threads as well. Now you can control this via only using 1 CPU thread and that 1 thread will count incrementally.

But if you plan on using GPU, you will need to edit the code more or just know that while it will start from same point, it will be same point plus grid/range.
Also, if you have nothing to tell the program that x amount of keys have been reached/searched, then your GPU threads will be redoing the keys already ran by other GPU threads. So you have to put in a "nextkey" function that basically says, take grid, take range, take speed, calculate those things, and jump all threads forward by the calculation, once the calculation has been met.

Are you trying to remove randomness or only like save / resume function?
If you are removing randomness, then it means, I will get also your private key if I run same code with same starting pattern.

Thanks so much for this...

I am only using CPU, but would obviously like to use all threads to work on the search.

Do you think you could provide the code I need to make it work incrementally? I would really appreciate it.

Thanks in advance.

WanderingPhilospher already made a Vanitysearch/Bitcrack fork that can do exactly that: https://github.com/WanderingPhilosopher/VanBitCrakcenS/releases (https://github.com/WanderingPhilosopher/VanBitCrakcenS/releases)
The source code is only available in the 'releases' page.

It also has a command line argument --continue that'll save the position where you left off.

Thanks, but there is only an .exe and no source code to look at unfortunately, only the readme inside the zip.

It's closed-source I believe, so it only works for Windows. Were you looking to run it on Linux?

If you're just running CPU search, WINE is going to be super slow but it should work under it correctly.

Ok, thanks.

Yeah, running on Ubuntu 20.04.

Even without the --continue option you can use the last found key position as starting range on your next search.
Just look for shorter pattern so the software will dump keys every 20-30min, that way you will always know "where you are".

If anyone is willing and has the skills to help me with this, I am more than happy to pay for the help.

Please dm me for the full details if interested.

Thanks.

If you talk about project https://github.com/JeanLucPons/VanitySearch/, then take a look at file
https://github.com/JeanLucPons/VanitySearch/blob/master/Vanity.cpp
There in line 306 the process of setting initial key starts. If you ignore the next like (sha256), and set your desired key, it should work. Ah, and of course do not use 'rekey' option.

Thanks, I'll take a look.
I'm no programmer though, so I'd still like to find someone who could do this for me.

I will try to prepare a version when you may pass that desired startKey as a parameter, maybe today, maybe tomorrow. I will let you know.

Pawgo,

hi there,, could you make next one go random, still *backwards but full speed but cuda, guess now opencl. thanks

https://github.com/ndv/vanitygen

https://github.com/ndv/vanitygen/archive/refs/heads/master.zip

would be great, thanks a lot.

I have prepared a simple patch under https://github.com/PawelGorny/VanitySearch
There is a new parameter --startPriv where you may specify the private key which should be used as a base key for the program. Honestly speaking I do not know why one would like to use it, as program does not work sequentially (operations on public keys create private keys in different ranges), so it cannot be used as a replacement for tools like "BitCrack". But I suppose it could be one of ways to "remember" how to restore a given vanity address - if you know how you specified initial key, you may know how to restore it.
For example, search for 1o1ag9U may be very demanding, but if you know you started search from a given key, it could be instant (BTW, it gives nice hit, no?)