Pages:
Author

Topic: Vanitygen: Vanity bitcoin address generator/miner [v0.22] - page 23. (Read 1153678 times)

legendary
Activity: 3808
Merit: 1723
Pretty sure people will start modding this software to optimize for the RX GPUs to try and solve those BTCs in the old 32BTC brute force private key contest.

Its almost reached the point, where brute forcing the private keys for the 0.54BTC address will yield more profit than mining ETH or ZEC.
newbie
Activity: 56
Merit: 0
Find the version of solidcoin addresses and use this
legendary
Activity: 3290
Merit: 16489
Thick-Skinned Gang Leader and Golden Feather 2021
btw can someone response to my question a few post earlier
anyhow to modify the code to also work/search on compressed addresses
There has been someone who made this changes, and posted it in this thread. You'll have to search a bit, this thread has too many pages to quickly find back the link.
I never used it, as I have a hard time trusting new programs that create private keys. You could at least use it to compare the source.
hero member
Activity: 1232
Merit: 738
Mixing reinvented for your privacy | chipmixer.com
...The more times you try, the more likely it becomes to roll a 6.
Dice have no memory. The chance to roll a 6 is the same at every throw. So it is NOT more likely to throw a 6 the more times you try.

Guys, I've asked about probability and time previously: 1, 2 and got the answer that "Dice have no memory."

Okay, but I still could not understand what does it mean on practice. And to illustrate my frustration here is the animated image (actually it is html+css).

So, I could search forever for my 1 exact 9-prefixed address?
you should read on math subject of probability and chance
in short, probability is theoritical calculation on possible outcomes while chance is based on luck factor
in this vanitygen case, your luck depends on random seed producing targeted pattern
thus the chance is the same everytime because you starting with random seed every time

If you're running searches for months, you may want to make a longer list of words to search for. By making a list with prefixes you may find more cool addresses in the same amount of time.
and I agree with what he said, add a few more patterns to make it worthwhile
so with multiple pattern search on single run you can get your other desired patterns at once
for example: 1Thirdspace 1Th3rdspace 1Thirdsp4ce 1Th3rdsp4ce 13rdspace
if you just do single pattern, you might missed the chance hitting the other patterns
I wish I have the power to do that kind of pattern
but I was a bit lucky with 1Third address (on profile) using only cpu power
I got it in around 10-12 hour while it says 50% in 1.1d at the beginning

btw can someone response to my question a few post earlier
anyhow to modify the code to also work/search on compressed addresses
newbie
Activity: 4
Merit: 0
...The more times you try, the more likely it becomes to roll a 6.
Dice have no memory. The chance to roll a 6 is the same at every throw. So it is NOT more likely to throw a 6 the more times you try.

Guys, I've asked about probability and time previously: 1, 2 and got the answer that "Dice have no memory."

Okay, but I still could not understand what does it mean on practice. And to illustrate my frustration here is the animated image (actually it is html+css).

So, I could search forever for my 1 exact 9-prefixed address?
legendary
Activity: 1948
Merit: 2097
I have a my own generator (for Linux) that produces private key + address but not in base58 format.

I have another program in Python too that produces private key + address, I should search it. I don't remember performance, but surely much more than 1500keys/s. Are you interested?

This smells like jhdscript will soon open a new topic: 'Please Help! My Bitcoins have been stolen.'
My answer might be: 'Sorry for your loss'

Thanks for the trust.   Cheesy

Anyway my program generates only "consecutive" keys. You provide:

1) the private key to start from
2) how many keys you want to compute

and it generates the corresponding addresses (hash of public keys, not base58 encoded). This is the output if you start from key = 1:

Code:
0+0000000000000000000000000000000000000000000000000000000000000001   751e76e8199196d454941c45d1b3a323f1433bd6
1+0000000000000000000000000000000000000000000000000000000000000001   06afd46bcdfd22ef94ac122aa11f241244a37ecc
2+0000000000000000000000000000000000000000000000000000000000000001   7dd65592d0ab2fe0d0257d571abf032cd9db93dc
3+0000000000000000000000000000000000000000000000000000000000000001   c42e7ef92fdb603af844d064faad95db9bcdfd3d
4+0000000000000000000000000000000000000000000000000000000000000001   4747e8746cddb33b0f7f95a90f89f89fb387cbb6
5+0000000000000000000000000000000000000000000000000000000000000001   7fda9cf020c16cacf529c87d8de89bfc70b8c9cb
6+0000000000000000000000000000000000000000000000000000000000000001   5dedfbf9ea599dd4e3ca6a80b333c472fd0b3f69
7+0000000000000000000000000000000000000000000000000000000000000001   9652d86bedf43ad264362e6e6eba6eb764508127
8+0000000000000000000000000000000000000000000000000000000000000001   b46abf4d9e1746e33bcc39cea3de876c29c4adf3
9+0000000000000000000000000000000000000000000000000000000000000001   185140bb54704a9e735016faa7a8dbee4449bddc
a+0000000000000000000000000000000000000000000000000000000000000001   362995a6e6922a04e0b832a80bc56c33709a42d2
b+0000000000000000000000000000000000000000000000000000000000000001   dd100be7d9aea5721158ebde6d6a1fd8fff93bb1
c+0000000000000000000000000000000000000000000000000000000000000001   57526b1a1534d4bde788253281649fc2e91dc70b
d+0000000000000000000000000000000000000000000000000000000000000001   726d44b7af8228257c030bafe764d3c5839d5c02
e+0000000000000000000000000000000000000000000000000000000000000001   9fc5dbe5efdce10374a4dd4053c93af540211718
f+0000000000000000000000000000000000000000000000000000000000000001   60aa32549d990a09863b8fd4ce611ebd70bb310b
10+0000000000000000000000000000000000000000000000000000000000000001   4f99bbf75707e44bc2afa65337dece914e817aac


It is only up to the user to choose which keys to generate, not up to the program.

Besides I don't think that jhdscript needs to store a so huge amount of addresses to send some bitcoin there. Maybe it is only a statistical project.


@jhdscript

I made 2 tests (writing speed, Xeon CPU E3-1505 3 GHz + SSD, Ubuntu Mate 17.04)

1) supervanitygen:  about 220K keys / minute (8 threads,  that confirms that vanitygen-like program are not suited to your case)

2) my own generator: 75M keys / minute (-> 6,5GB file / minute) per 1 core. I got about 175 Mkeys / minute with 4 cores.

Unfortunately if I try to compile it for Windows the results I get are not correct anymore.  When I will have more time I will give it a look. For now I can't help you  (unless you decide to use Linux).
Honestly I can't figure out why you need to fill an hard disk so fast. It takes about 20 hours to fill 4TB.
member
Activity: 168
Merit: 10
It's important to note that searching for short addresses (<34 standard character address length) by utilising "1"*n patterns has a greater difficulty than other patterns of the same length.

I have found several hundred 31 length addresses and a few (2 or 3) 30 character addresses running my 7950 at work over a many-month long period of time.
hero member
Activity: 1232
Merit: 738
Mixing reinvented for your privacy | chipmixer.com
it's been awhile since last time I'm following this thread
as I look into the generated address/key pair, they are seem all uncompressed
with the increasing tx fee, the need of compressed address becomes common
is there a way to (turn on) search pattern on both uncompressed and compressed addresses
sound like a waste if only checking pattern on uncompressed address generated,
because there is also corresponding compressed address that can be checked at the same time
AGD
legendary
Activity: 2070
Merit: 1164
Keeper of the Private Key
I have a my own generator (for Linux) that produces private key + address but not in base58 format.

I have another program in Python too that produces private key + address, I should search it. I don't remember performance, but surely much more than 1500keys/s. Are you interested?

yes i m interested. I dont need base58, only compress pubkey and private key

This smells like jhdscript will soon open a new topic: 'Please Help! My Bitcoins have been stolen.'
My answer might be: 'Sorry for your loss'
member
Activity: 266
Merit: 10
yes i m interested. I dont need base58, only compress pubkey and private key
legendary
Activity: 1948
Merit: 2097
I have a my own generator (for Linux) that produces private key + address but not in base58 format.

I have another program in Python too that produces private key + address, I should search it. I don't remember performance, but surely much more than 1500keys/s. Are you interested?
member
Activity: 266
Merit: 10
i need private keys too. The soft supervanity is exactly was i looking for but for windows :-(
legendary
Activity: 1948
Merit: 2097
I have already try it but compile under Windows OS failed :-(

You need only addresses or private keys too?
You need addresses in base58 or only as hexdecimal string?
member
Activity: 266
Merit: 10
I have already try it but compile under Windows OS failed :-(
legendary
Activity: 1948
Merit: 2097
Any ideas are welcome


https://github.com/klynastor/supervanitygen

5 Mkeys/s with 4 Cores (only cpu, only compressed keys)

Code:
sudo apt-get install build-essential automake autoconf libtool libgmp3-dev git

git clone https://github.com/klynastor/supervanitygen.git

cd vanitygen

make
 
./vanitygen -k -t 8 1 > file_addresses.txt

(t is num of thread)

Code:
./vanitygen -h

./vanitygen: invalid option -- 'h'
Usage: ./vanitygen [options] prefix ...
Options:
  -c count  Stop after 'count' solutions; default=1
  -i        Match case-insensitive prefixes
  -k        Keep looking for solutions indefinitely
  -q        Be quiet (report solutions in CSV format)
  -t num    Run 'num' threads; default=8
  -v        Be verbose

Super Vanitygen v0.3

Code:
less file_addresses.txt

Private Key:   L3FPYTe2DRnECbCY4jgHLQfYfCuMN2Vkw8cXdChv85iChdQRUc5D
Address:       1Fs31wvU5s6cSapgaKJggBXtB3ZgYebLQ7
---

Private Key:   L3pew4fRWmD7qnwhDeBYfaEVGvBiv5tn1VKgVMT3ohxs2ubNJ8Ax
Address:       13Qos8JSu5d1TUfHt7YGKGz87dPv8LDxef
---

Private Key:   L4DChbkEeAtNn7zdQHeUMxrPrPs1iAND4vkopTTKLsxrREbJwYsc
Address:       14v1o8FUqSrAWgPpFZ3pKhR7arfxvKinBB
---

Private Key:   L5JESCLKM3CRqXUrBT4hR4wMdkPLTKW1s2t72SaGd7RcZbDHuYBP
Address:       18icHaTG6R7xaPdJRW9ggmXsoqmuiAPCfs
---

Private Key:   L1w3oktocmFMmKEqvmHNL15bNW1A7BWRSbARS7RRghvaGNru7ggy
Address:       1Lj5nRZ9N3Xn4TLXUNyFqRXtoCjRmLXRET
---

Private Key:   KxL5A2zXVeKJSwLVArmWUUn1N722gF3zqNc9xHzHsjAdWcQve85R
Address:       1K6sw4ogHyV8f2a8ABqUMJeFba56XvFySn
---

Private Key:   KzUPWtGb38VADobCjpEptqCkRVpUaa4Gfg3MjXRCLANRSeqKgWks
Address:       1Mmh3kMshGeYwnXxPwG8UmLxEZkhFAgLmh
---

Private Key:   L54ocsDvSM2v1P1ius3KN8jdi7xsDMxLhqAMggDgbycw9WeHgvfz
Address:       1EhTJbj34AEwyPKitg5qKuinMYnUpxnAQn
---

Private Key:   L1eCcQ88ZytxKNw1YNu7aaX59wruF3YwLsiH4tveEx9B9xJu9ykc
Address:       18qqzitiY1D8LQEGtCPH2anbvGLTrc8Cf4
---

Private Key:   KzTikQCwHJ1nohEvhkSaZ67sQMhqP14sm2C4zmnw1mPaWgjd8rP2
Address:       114nUfPxYfpDbkwoVyawi6po4Bf9RAkiyX
---

Private Key:   KxYhci1QTbh7LZdAM83WQF6if9YNDyfb48c4aTJKQof9wdptFZiM
Address:       1E1FMdAw9ikwRuxeuKVBiDGnPXVwd5x6Ni
---

If you need only addresses, without private keys:

Code:
grep "Address" file_addresses.txt | awk '{ print $2 }'

1Fs31wvU5s6cSapgaKJggBXtB3ZgYebLQ7
13Qos8JSu5d1TUfHt7YGKGz87dPv8LDxef
14v1o8FUqSrAWgPpFZ3pKhR7arfxvKinBB
18icHaTG6R7xaPdJRW9ggmXsoqmuiAPCfs
1Lj5nRZ9N3Xn4TLXUNyFqRXtoCjRmLXRET
1K6sw4ogHyV8f2a8ABqUMJeFba56XvFySn
1Mmh3kMshGeYwnXxPwG8UmLxEZkhFAgLmh
1EhTJbj34AEwyPKitg5qKuinMYnUpxnAQn
18qqzitiY1D8LQEGtCPH2anbvGLTrc8Cf4
114nUfPxYfpDbkwoVyawi6po4Bf9RAkiyX
1E1FMdAw9ikwRuxeuKVBiDGnPXVwd5x6Ni
1HSZFKCp8hiWrT4QDjpadPWBxYf9eUV6eW
17WiFAk3he9CBYd6NNSgPQsbrxWNZEndyY
15fzWX5dN8FT3Um7G6UMX2wmrxXMj8SJuc
12uFRmoWLC5LpdwJSKTb684e2K6XvJP9uQ
1Hj858no3tFnNPEBnio1wvqNWjdJR13Q3N
17aNycU8R2FxDX2LS3YJk8pTRY9QB3iume
16LeEJG73zgik9oFt7uY9MCWPbQSBqEZF4
1HhVnuwsBNQh58PsQ4Zmxk5kpLgujgnLjL
1HGggNYidJ1mhVsfFwmgQeembPVbtjwYFR
1JNEfBL4i7shMhFSQStRC64hmKPoYEo5S3
1PXbLjAzju2XhaHauaFxLPL2G19H8mXUbQ
1Nj984jVz65Dp9NU2aWE9NUSx3yUYD3uEP
1NDszUXy5QEHftf5JkEQUMAtgvUiAJ51pK
1HfWqcGde46rfTaYHmsacXeDkYAFeadtzs
1yQaSMCkLy1qNELtLZbxSecJaEygJPsCG
1QDhShyVT6jXNKVyG6mW2uSb9UJE4PDu35
1Fp4kNt3jEuPU37qoC4ZzUeH5ocVYFNonC
1Afpg8Woo5prgdCxvqcz1ty2YBU2UUki2J
12ZKnPV1QsSUEhxoskxYNkfSL24bja2GAS
member
Activity: 266
Merit: 10
Actually I m near 1500key/s using a custom application but I need at least 100000 keys/second for an educational project with students.

Vanitygen appears great soft but it outputs very low number of keys :-(

Any ideas are welcome
legendary
Activity: 1948
Merit: 2097
I show thé code but don t find what tout modifs on pattern.c to write all résultats :-(

Do you want only to generate many addresses? What speed do you need?
member
Activity: 266
Merit: 10
I show thé code but don t find what tout modifs on pattern.c to write all résultats :-(
member
Activity: 89
Merit: 11
... snip ...
As for why 168 kkeys/s for approximately 5 seconds only outputs 2971 addresses: that's only 1 in approximately 280. I'm not sure why that is.

Vanitygen is a address search application, it runs the calculations in address-batches to optimize the heavy EC_POINT calculations.
The search functionality will disregard remaining calculations in the batch when it finds a match.
If only a "1" is specified in the search, each calculation yields a valid result, so the first in the batch is a match, the rest is
disregarded. If you want to use vanitygen as an address generator, you need to change the code to search in smaller batches.

I don't know the specifics of oclvanitygen, but most software that runs on a GPU runs even larger (parallel) batches.
If the same match and throw away routine is used, oclvanitygen will be less productive then vanitygen on small searches.
legendary
Activity: 3290
Merit: 16489
Thick-Skinned Gang Leader and Golden Feather 2021
I have a question: using vanitygen it outputs I generate 20Mkeys/s

but when i start:

vanitygen -k -q -i -o out.txt 1

it saves only few addresses.

I don t understand the delta between the power displayed (20Mkeys/s) and the number of address found.
Are you sure you get 20 Mkeys/s out of vanitygen? The speed sounds like you're using oclvanitygen.

I ran both for about 5 seconds:
Code:
./vanitygen -k -q -i -o out.txt 1
[168.47 Kkey/s][total 669228][Found 2971]

./oclvanitygen -k -q -i -o out.txt 1
[4.84 Mkey/s][total 31457280][Found 5]
I've been struggling to understand this before, but I don't understand the details enough to know exactly why this is.
From what I understand: oclvanitygen can only output about 1 key per second, it takes time to restart the process in the GPU. Vanitygen searches short prefixes much faster, but loses speed too when it has to output all addresses.
As for why 168 kkeys/s for approximately 5 seconds only outputs 2971 addresses: that's only 1 in approximately 280. I'm not sure why that is.
Pages:
Jump to: