Search content
Sort by
Showing 20 of 21 results by alexxino
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I have developed a prediction model based on the @HomelessPhD model for alpha values:
https://github.com/HomelessPhD/BTC32
It targets puzzle private keys with a deviation of 0.0000000001 %.
python3 test.py 68
Puzzle 68 Calculation:
Using alpha: 8.692996380248756
Base exponential model: 0.68972090704257297155081468833675824716161023623689914791953650562051467261304 4419972598777231639024182489182413058156841483121232343334326952277688035030318 1311309574260048040167879840662353500733521425500975021869380914054885130184442 40544507079388243203845236809052465256422016436329883051889524096 * 2.00446149587820417640494244738360788449393817055989304597589376020405549833178 4239005365118701510143617670147330576209009738631394722016490414926974514298110 3364613583395133560524755600665108274702675918184495985595413655135405238097981 4864413726673117061462450025066948963321434607944444810622903302^n
Real Value: 219898266213316039825
Predicted Value: 219898266215462633472.00
Percentage error: 0.00000000%
python3 test.py 69
Puzzle 69 Prediction:
Using interpolated alpha: -7.804319
According to this, puzzle 69 starts with 1ba45e.....
I don't have the nerves to improve this for the better.
https://github.com/HomelessPhD/BTC32
It targets puzzle private keys with a deviation of 0.0000000001 %.
Code:
import numpy as np
from mpmath import mp
import argparse
# Set very high precision
mp.dps = 300
# Target numbers (ordinal, value)
target_numbers = [
(1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
(11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
(17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
(22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
(26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
(30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
(34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
(38, 146971536592), (39, 323724968937), (40, 1003651412950),
(41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
(44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
(47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
(50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
(53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
(56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
(59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
(62, 3908372542507822062), (63, 8993229949524469768),
(64, 17799667357578236628), (65, 30568377312064202855),
(66, 46346217550346335726), (67, 132656943602386256302),
(68, 219898266213316039825), (70, 970436974005023690481)
]
# Provided alpha values
alpha_values = {
20: -5.509999999999367, 21: -4.8099999999993575, 22: 6.690000000000806, 23: 4.309999999879222,
24: -5.109999999999362, 25: -2.4933006701008145, 26: 23.19000000000104, 27: 50.01000000165623,
28: 50.01000000165623, 29: 4.490000000000775, 30: -4.30999999999935, 31: -4.8036514600379405,
32: 2.7900000000007505, 33: 10.110000011655663, 34: 8.496609620547714, 35: 1.6905278399975268,
36: 2.2900000000007434, 37: 6.506918969897979, 38: 1.8912248499932935, 39: 2.9099999998792025,
40: -2.809999999999329, 41: 5.2945524899731184, 42: 5.690000000000792, 43: -4.691035100114615,
44: -3.9099999999993447, 45: 2.5900000000007477, 46: 50.01000000165623, 47: -4.50218804004683,
48: 6.909999999879259, 49: 28.510000011655915, 50: 2.495913989964804, 51: -2.5900000001208756,
52: -2.5099999999993248, 53: 50.01000000165623, 54: 2.4900000000007463, 55: -5.00999999999936,
56: 3.8099999998792153, 57: -2.1943843400942242, 58: 8.890000000000837, 59: -3.009999999999332,
60: -2.2099999999993205, 61: 3.1099999998792054, 62: -6.000280060058447, 63: -2.490000000120874,
64: -2.809999999999329, 65: -19.689999988344763, 66: 2.7931615399815364, 67: -4.709999999999356,
68: 8.692996380248756, 70: -24.301635149307526
}
def calculate_prediction(puzzle_number, alpha):
# Get all previous data points
ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
if len(ordinals) < 2:
print(f"Not enough data points to make a prediction for puzzle {puzzle_number}")
return None, None, None
log_values = np.array([float(mp.log(val)) for val in values], dtype=float)
weights = np.linspace(0.5, 1, len(ordinals))
coefficients = np.polyfit(ordinals, log_values, 1, w=weights)
a = mp.exp(coefficients[1])
b = mp.exp(coefficients[0])
correction = (((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha
predicted_value = (a * mp.power(b, puzzle_number)) - correction
return predicted_value, a, b
def interpolate_alpha(puzzle_number):
"""Interpolate alpha for missing puzzle numbers"""
known_puzzles = sorted(alpha_values.keys())
if puzzle_number < min(known_puzzles) or puzzle_number > max(known_puzzles):
return 0.0 # Default value if outside known range
# Find closest lower and higher puzzle numbers
lower = max([p for p in known_puzzles if p < puzzle_number])
higher = min([p for p in known_puzzles if p > puzzle_number])
# Linear interpolation
alpha_range = alpha_values[higher] - alpha_values[lower]
position = (puzzle_number - lower) / (higher - lower)
return alpha_values[lower] + (alpha_range * position)
def format_mp(value, decimals=None):
"""Format mpmath value with specified decimal places"""
if decimals is not None:
return f"{float(value):,.{decimals}f}".replace(',', '')
return mp.nstr(value, mp.dps)
def main(puzzle_number):
if puzzle_number == 69:
# Special case for puzzle 69 - use interpolated alpha
alpha = interpolate_alpha(69)
predicted_value, a, b = calculate_prediction(69, alpha)
print("\nPuzzle 69 Prediction:")
print(f"Using interpolated alpha: {alpha:.6f}")
print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
print(f"Predicted Value: {format_mp(predicted_value, 2)}")
# Compare with n=70
n70_value = next(x[1] for x in target_numbers if x[0] == 70)
growth_rate = n70_value / predicted_value
print(f"Growth to n=70: {float(growth_rate):.6f}x")
print(f"Actual n=70 value: {format_mp(n70_value)}")
return
if puzzle_number not in alpha_values:
print(f"No alpha value available for puzzle {puzzle_number}")
return
alpha = alpha_values[puzzle_number]
predicted_value, a, b = calculate_prediction(puzzle_number, alpha)
if predicted_value is None:
return
real_value = next((x[1] for x in target_numbers if x[0] == puzzle_number), None)
print(f"\nPuzzle {puzzle_number} Calculation:")
print(f"Using alpha: {alpha}")
print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
if real_value is not None:
print(f"Real Value: {format_mp(real_value)}")
print(f"Predicted Value: {format_mp(predicted_value, 2)}")
if real_value is not None:
error_percentage = abs((predicted_value - real_value) / real_value) * 100
print(f"Percentage error: {format_mp(error_percentage, 10)}%")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Calculate puzzle values using provided alpha values.")
parser.add_argument("puzzle_number", type=int, help="Puzzle number to calculate")
args = parser.parse_args()
main(args.puzzle_number)
If anyone knows what to do next with this - here you go.from mpmath import mp
import argparse
# Set very high precision
mp.dps = 300
# Target numbers (ordinal, value)
target_numbers = [
(1, 1), (2, 3), (3, 7), (4, 8), (5, 21), (6, 49), (7, 76), (8, 224), (9, 467), (10, 514),
(11, 1155), (12, 2683), (13, 5216), (14, 10544), (15, 26867), (16, 51510),
(17, 95823), (18, 198669), (19, 357535), (20, 863317), (21, 1811764),
(22, 3007503), (23, 5598802), (24, 14428676), (25, 33185509),
(26, 54538862), (27, 111949941), (28, 227634408), (29, 400708894),
(30, 1033162084), (31, 2102388551), (32, 3093472814), (33, 7137437912),
(34, 14133072157), (35, 20112871792), (36, 42387769980), (37, 100251560595),
(38, 146971536592), (39, 323724968937), (40, 1003651412950),
(41, 1458252205147), (42, 2895374552463), (43, 7409811047825),
(44, 15404761757071), (45, 19996463086597), (46, 51408670348612),
(47, 119666659114170), (48, 191206974700443), (49, 409118905032525),
(50, 611140496167764), (51, 2058769515153876), (52, 4216495639600700),
(53, 6763683971478124), (54, 9974455244496707), (55, 30045390491869460),
(56, 44218742292676575), (57, 138245758910846492), (58, 199976667976342049),
(59, 525070384258266191), (60, 1135041350219496382), (61, 1425787542618654982),
(62, 3908372542507822062), (63, 8993229949524469768),
(64, 17799667357578236628), (65, 30568377312064202855),
(66, 46346217550346335726), (67, 132656943602386256302),
(68, 219898266213316039825), (70, 970436974005023690481)
]
# Provided alpha values
alpha_values = {
20: -5.509999999999367, 21: -4.8099999999993575, 22: 6.690000000000806, 23: 4.309999999879222,
24: -5.109999999999362, 25: -2.4933006701008145, 26: 23.19000000000104, 27: 50.01000000165623,
28: 50.01000000165623, 29: 4.490000000000775, 30: -4.30999999999935, 31: -4.8036514600379405,
32: 2.7900000000007505, 33: 10.110000011655663, 34: 8.496609620547714, 35: 1.6905278399975268,
36: 2.2900000000007434, 37: 6.506918969897979, 38: 1.8912248499932935, 39: 2.9099999998792025,
40: -2.809999999999329, 41: 5.2945524899731184, 42: 5.690000000000792, 43: -4.691035100114615,
44: -3.9099999999993447, 45: 2.5900000000007477, 46: 50.01000000165623, 47: -4.50218804004683,
48: 6.909999999879259, 49: 28.510000011655915, 50: 2.495913989964804, 51: -2.5900000001208756,
52: -2.5099999999993248, 53: 50.01000000165623, 54: 2.4900000000007463, 55: -5.00999999999936,
56: 3.8099999998792153, 57: -2.1943843400942242, 58: 8.890000000000837, 59: -3.009999999999332,
60: -2.2099999999993205, 61: 3.1099999998792054, 62: -6.000280060058447, 63: -2.490000000120874,
64: -2.809999999999329, 65: -19.689999988344763, 66: 2.7931615399815364, 67: -4.709999999999356,
68: 8.692996380248756, 70: -24.301635149307526
}
def calculate_prediction(puzzle_number, alpha):
# Get all previous data points
ordinals = np.array([x[0] for x in target_numbers if x[0] < puzzle_number], dtype=float)
values = np.array([x[1] for x in target_numbers if x[0] < puzzle_number], dtype=float)
if len(ordinals) < 2:
print(f"Not enough data points to make a prediction for puzzle {puzzle_number}")
return None, None, None
log_values = np.array([float(mp.log(val)) for val in values], dtype=float)
weights = np.linspace(0.5, 1, len(ordinals))
coefficients = np.polyfit(ordinals, log_values, 1, w=weights)
a = mp.exp(coefficients[1])
b = mp.exp(coefficients[0])
correction = (((2 ** puzzle_number) - 1) - (2 ** (puzzle_number - 1))) / alpha
predicted_value = (a * mp.power(b, puzzle_number)) - correction
return predicted_value, a, b
def interpolate_alpha(puzzle_number):
"""Interpolate alpha for missing puzzle numbers"""
known_puzzles = sorted(alpha_values.keys())
if puzzle_number < min(known_puzzles) or puzzle_number > max(known_puzzles):
return 0.0 # Default value if outside known range
# Find closest lower and higher puzzle numbers
lower = max([p for p in known_puzzles if p < puzzle_number])
higher = min([p for p in known_puzzles if p > puzzle_number])
# Linear interpolation
alpha_range = alpha_values[higher] - alpha_values[lower]
position = (puzzle_number - lower) / (higher - lower)
return alpha_values[lower] + (alpha_range * position)
def format_mp(value, decimals=None):
"""Format mpmath value with specified decimal places"""
if decimals is not None:
return f"{float(value):,.{decimals}f}".replace(',', '')
return mp.nstr(value, mp.dps)
def main(puzzle_number):
if puzzle_number == 69:
# Special case for puzzle 69 - use interpolated alpha
alpha = interpolate_alpha(69)
predicted_value, a, b = calculate_prediction(69, alpha)
print("\nPuzzle 69 Prediction:")
print(f"Using interpolated alpha: {alpha:.6f}")
print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
print(f"Predicted Value: {format_mp(predicted_value, 2)}")
# Compare with n=70
n70_value = next(x[1] for x in target_numbers if x[0] == 70)
growth_rate = n70_value / predicted_value
print(f"Growth to n=70: {float(growth_rate):.6f}x")
print(f"Actual n=70 value: {format_mp(n70_value)}")
return
if puzzle_number not in alpha_values:
print(f"No alpha value available for puzzle {puzzle_number}")
return
alpha = alpha_values[puzzle_number]
predicted_value, a, b = calculate_prediction(puzzle_number, alpha)
if predicted_value is None:
return
real_value = next((x[1] for x in target_numbers if x[0] == puzzle_number), None)
print(f"\nPuzzle {puzzle_number} Calculation:")
print(f"Using alpha: {alpha}")
print(f"Base exponential model: {format_mp(a)} * {format_mp(b)}^n")
if real_value is not None:
print(f"Real Value: {format_mp(real_value)}")
print(f"Predicted Value: {format_mp(predicted_value, 2)}")
if real_value is not None:
error_percentage = abs((predicted_value - real_value) / real_value) * 100
print(f"Percentage error: {format_mp(error_percentage, 10)}%")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Calculate puzzle values using provided alpha values.")
parser.add_argument("puzzle_number", type=int, help="Puzzle number to calculate")
args = parser.parse_args()
main(args.puzzle_number)
python3 test.py 68
Puzzle 68 Calculation:
Using alpha: 8.692996380248756
Base exponential model: 0.68972090704257297155081468833675824716161023623689914791953650562051467261304 4419972598777231639024182489182413058156841483121232343334326952277688035030318 1311309574260048040167879840662353500733521425500975021869380914054885130184442 40544507079388243203845236809052465256422016436329883051889524096 * 2.00446149587820417640494244738360788449393817055989304597589376020405549833178 4239005365118701510143617670147330576209009738631394722016490414926974514298110 3364613583395133560524755600665108274702675918184495985595413655135405238097981 4864413726673117061462450025066948963321434607944444810622903302^n
Real Value: 219898266213316039825
Predicted Value: 219898266215462633472.00
Percentage error: 0.00000000%
python3 test.py 69
Puzzle 69 Prediction:
Using interpolated alpha: -7.804319
According to this, puzzle 69 starts with 1ba45e.....
I don't have the nerves to improve this for the better.
I'm trying to redo your work here!
I have tried to get the alphas using Octave but it gives me super different values, none of them negative! Did you make changes in the analysis.m file? I have modified the 'btc32_keys_dec.csv file setting only from 20# to 70# but alphas are way too different than yours. Any clue what I'm doing wrong?
Thanks for this quick optimized Kangaroo program.
Is it possible to have the "save work" option and "load work" from file like in JLP's Kangaroo?
Thanks
Is it possible to have the "save work" option and "load work" from file like in JLP's Kangaroo?
Thanks
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
When I solved #125 I gave up because it became boring. I thought someone else would solve #130, but nobody did it, so after a year I started again and I spent about two months to solve #130.
Yes you can use old DPs to solve next puzzle, it helps a bit.
I will try to finish solving #135 in 2025.
Yes you can use old DPs to solve next puzzle, it helps a bit.
I will try to finish solving #135 in 2025.
What is the hardware that are you planning to use? In case of 4090, how many pieces ?
If you are bored of solving this alone, you can always create a pool so people can contribute to solve it faster. I definitely would join that!
Hi everybody,
I'm writing a light beta library in C to run Pollard kangaroo algorithm on ARM64 CPU.
I am at the very beginning of this project but i am able to do benchmark.
when the library will be functionnal i will posted it on github.
the library (a shared object file) will be callable by python with ctypes module
The herds of kangaroos will be controlled directly with python (for convenience and ease).
The idea is to have a lot of clients running on ARM64 low cost CPU to compute parallelized secp256k1 points additions .
The memory (DP points of a client) will be returned with a client-server socket data transfer (server will have the main hashtable of DP ) as the Kangaroo software from Jean-Luc Pons.
The first benchmark on ARM (Raspberry PI 400 without overclocking ) are better than I expected (around 30MKeys/s with 4 cores).
What do you think about this performance ?
Do you know if there is a very low cost card (mini PC) with ARM CPU (similar to raspberry pi compute module 4 see link below) to do the work (in a parallelized way) and see if the ratio (computing power)/price might be better compared to the latest GPU CUDA Compatible graphics card.
https://www.raspberrypi.org/products/compute-module-4/?variant=raspberry-pi-cm4001000
I'm writing a light beta library in C to run Pollard kangaroo algorithm on ARM64 CPU.
I am at the very beginning of this project but i am able to do benchmark.
when the library will be functionnal i will posted it on github.
the library (a shared object file) will be callable by python with ctypes module
The herds of kangaroos will be controlled directly with python (for convenience and ease).
The idea is to have a lot of clients running on ARM64 low cost CPU to compute parallelized secp256k1 points additions .
The memory (DP points of a client) will be returned with a client-server socket data transfer (server will have the main hashtable of DP ) as the Kangaroo software from Jean-Luc Pons.
The first benchmark on ARM (Raspberry PI 400 without overclocking ) are better than I expected (around 30MKeys/s with 4 cores).
What do you think about this performance ?
Do you know if there is a very low cost card (mini PC) with ARM CPU (similar to raspberry pi compute module 4 see link below) to do the work (in a parallelized way) and see if the ratio (computing power)/price might be better compared to the latest GPU CUDA Compatible graphics card.
https://www.raspberrypi.org/products/compute-module-4/?variant=raspberry-pi-cm4001000
Is this ARM64 code published somewhere ? I would like to run some tests in some raspberries.
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Totally true, that is a millionaire hobby and he broke the guiness record solving those puzzles but if we create a pool to contribute the search for 135, it can be the first puzzle in some time that has quite a good prize and can be shared between all the contributors. This way we can solve it in less that a year.
Any thoughts?
Any thoughts?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I'm now looking for a place to rent ASICs where I can run custom software. However, there are firmware restrictions. Most ASICs, such as those from Bitmain (Antminer) or MicroBT (Whatsminer), come with firmware that may limit the ability to install custom software.
Did you check bitaxe family ? Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Puzzle #60 with a MacBook M1 Max
4.01e+03 seconds is 4010 seconds. So 1 hour and 11 minutes
I'm curious how much would it be with multithreading.
4.01e+03 seconds is 4010 seconds. So 1 hour and 11 minutes
I'm curious how much would it be with multithreading.
Code:
Ops: 1640142848 Table size: 25626624 Speed: 408909 ops/s
Ops: 1640964096 Table size: 25639463 Speed: 408910 ops/s
Private Key: 0xfc07a1825367bbe
Ops: 1641142272 Stored: 25642283
Speed: 408885 ops/s
Finished in 4.01e+03 s
Ops: 1640964096 Table size: 25639463 Speed: 408910 ops/s
Private Key: 0xfc07a1825367bbe
Ops: 1641142272 Stored: 25642283
Speed: 408885 ops/s
Finished in 4.01e+03 s
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I realized something strange after some tests.
I have a lot of equipment. All running for searches about these puzzles.
To have fun, I chose to search via vanity in last days.
I have desktops and notebooks with latest and powerful intel chips, nvidia graphics, 120GB DDR5 etc. each. On vanity, these setups find ~20 addresses per day for each.
However, when I applied vanity via apple silicone chips (M1, M2, M3), daily found vanity addresses ~500 per each setup.
I observed the behavior, and when it finds a vanity address in the pool I search, immediately it finds 5-6 addresses more in milliseconds, it is moving to the numbers to check that might have the vanity around some near numbers while I'm generating those numbers using "random".
For example:
1MVDYUvrcMqdprCTYuthuaQxWWAL8Ty2KS 220647290646478288674
1MVDYE2EHY3VR3AXKrD7mYvpSgD2SGgqZb 257335783054352585279
1MVDYuE5HGPjYaEH72sZukwNXhdtdKSQRY 280101386265359359876
1MVDYNcMjPsAW1PQgjwCGRNwijJMSW1UcR 274962343828436157207
1MVDYGms9qGRsrDD7AuoyYJBZnJTzAj9B8 213173989571665196391
1MVDYnfq7s3yG8fdnhQ66cqDa4h2DNoGeB 247904416465366500764
1MVDYY8GUU8or4WfLSrsbHip8F7pwA4xpv 243282287509672730681
1MVDYxMNG8fKf9fvX3r5PmwNXY8tjfESsu 245042251007899478320
1MVDY8aYEQsCWqU2MVWRjhrLHaX28SHFky 270190501490895327846
These are found in the same second and it keeps this behavior.
This behavior made me crazy guys. I do not understand how it can do this.
I have a lot of equipment. All running for searches about these puzzles.
To have fun, I chose to search via vanity in last days.
I have desktops and notebooks with latest and powerful intel chips, nvidia graphics, 120GB DDR5 etc. each. On vanity, these setups find ~20 addresses per day for each.
However, when I applied vanity via apple silicone chips (M1, M2, M3), daily found vanity addresses ~500 per each setup.
I observed the behavior, and when it finds a vanity address in the pool I search, immediately it finds 5-6 addresses more in milliseconds, it is moving to the numbers to check that might have the vanity around some near numbers while I'm generating those numbers using "random".
For example:
1MVDYUvrcMqdprCTYuthuaQxWWAL8Ty2KS 220647290646478288674
1MVDYE2EHY3VR3AXKrD7mYvpSgD2SGgqZb 257335783054352585279
1MVDYuE5HGPjYaEH72sZukwNXhdtdKSQRY 280101386265359359876
1MVDYNcMjPsAW1PQgjwCGRNwijJMSW1UcR 274962343828436157207
1MVDYGms9qGRsrDD7AuoyYJBZnJTzAj9B8 213173989571665196391
1MVDYnfq7s3yG8fdnhQ66cqDa4h2DNoGeB 247904416465366500764
1MVDYY8GUU8or4WfLSrsbHip8F7pwA4xpv 243282287509672730681
1MVDYxMNG8fKf9fvX3r5PmwNXY8tjfESsu 245042251007899478320
1MVDY8aYEQsCWqU2MVWRjhrLHaX28SHFky 270190501490895327846
These are found in the same second and it keeps this behavior.
This behavior made me crazy guys. I do not understand how it can do this.
Do you have a binary to search vanity which runs on Silicon CPUs? I could not find any nor make it work, a lot of libraries are only for intel.
Could you share it ?
It is very simple vanity search using "random" and written in Python
import sqlite3
import random
from bit import Key
import bitcoin
# Connect to vanity_addresses.db for storing found vanity addresses
vanity_conn = sqlite3.connect('vanity_addresses.db')
vanity_cursor = vanity_conn.cursor()
# Create a table in vanity_addresses.db to store vanity addresses and private keys
vanity_cursor.execute('''
CREATE TABLE IF NOT EXISTS vanity_addresses (
address TEXT PRIMARY KEY,
private_key TEXT
)
''')
vanity_conn.commit()
def generate_vanity_address(prefix):
while True:
# Generate a new private key
private_key = random.randint(147573952589676412927, 295147905179352825855)
# Compute the corresponding public key
key = Key.from_int(private_key)
addr = key.address
addr_uncompressed = bitcoin. privkey_to_address(private_key)
if addr.startswith(prefix):
# Insert found vanity addresses into the vanity_addresses.db database
vanity_cursor.execute(
'INSERT INTO vanity_addresses (address, private_key) VALUES (?, ?)', (addr, str(private_key)))
vanity_conn.commit()
if addr_uncompressed.startswith(prefix):
# Insert found vanity addresses into the vanity_addresses.db database
vanity_cursor.execute(
'INSERT INTO vanity_addresses (address, private_key) VALUES (?, ?)', (addr_uncompressed, str(private_key)))
vanity_conn.commit()
# Log that a vanity address was found
# print(
# "Vanity Address found and inserted into the vanity_addresses.db database:", addr)
prefix = '1MVDY'
generate_vanity_address(prefix)
I was thinking something in objective C or C++ native langs for MacOs. Thanks for sharing the python script anyways
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I realized something strange after some tests.
I have a lot of equipment. All running for searches about these puzzles.
To have fun, I chose to search via vanity in last days.
I have desktops and notebooks with latest and powerful intel chips, nvidia graphics, 120GB DDR5 etc. each. On vanity, these setups find ~20 addresses per day for each.
However, when I applied vanity via apple silicone chips (M1, M2, M3), daily found vanity addresses ~500 per each setup.
I observed the behavior, and when it finds a vanity address in the pool I search, immediately it finds 5-6 addresses more in milliseconds, it is moving to the numbers to check that might have the vanity around some near numbers while I'm generating those numbers using "random".
For example:
1MVDYUvrcMqdprCTYuthuaQxWWAL8Ty2KS 220647290646478288674
1MVDYE2EHY3VR3AXKrD7mYvpSgD2SGgqZb 257335783054352585279
1MVDYuE5HGPjYaEH72sZukwNXhdtdKSQRY 280101386265359359876
1MVDYNcMjPsAW1PQgjwCGRNwijJMSW1UcR 274962343828436157207
1MVDYGms9qGRsrDD7AuoyYJBZnJTzAj9B8 213173989571665196391
1MVDYnfq7s3yG8fdnhQ66cqDa4h2DNoGeB 247904416465366500764
1MVDYY8GUU8or4WfLSrsbHip8F7pwA4xpv 243282287509672730681
1MVDYxMNG8fKf9fvX3r5PmwNXY8tjfESsu 245042251007899478320
1MVDY8aYEQsCWqU2MVWRjhrLHaX28SHFky 270190501490895327846
These are found in the same second and it keeps this behavior.
This behavior made me crazy guys. I do not understand how it can do this.
I have a lot of equipment. All running for searches about these puzzles.
To have fun, I chose to search via vanity in last days.
I have desktops and notebooks with latest and powerful intel chips, nvidia graphics, 120GB DDR5 etc. each. On vanity, these setups find ~20 addresses per day for each.
However, when I applied vanity via apple silicone chips (M1, M2, M3), daily found vanity addresses ~500 per each setup.
I observed the behavior, and when it finds a vanity address in the pool I search, immediately it finds 5-6 addresses more in milliseconds, it is moving to the numbers to check that might have the vanity around some near numbers while I'm generating those numbers using "random".
For example:
1MVDYUvrcMqdprCTYuthuaQxWWAL8Ty2KS 220647290646478288674
1MVDYE2EHY3VR3AXKrD7mYvpSgD2SGgqZb 257335783054352585279
1MVDYuE5HGPjYaEH72sZukwNXhdtdKSQRY 280101386265359359876
1MVDYNcMjPsAW1PQgjwCGRNwijJMSW1UcR 274962343828436157207
1MVDYGms9qGRsrDD7AuoyYJBZnJTzAj9B8 213173989571665196391
1MVDYnfq7s3yG8fdnhQ66cqDa4h2DNoGeB 247904416465366500764
1MVDYY8GUU8or4WfLSrsbHip8F7pwA4xpv 243282287509672730681
1MVDYxMNG8fKf9fvX3r5PmwNXY8tjfESsu 245042251007899478320
1MVDY8aYEQsCWqU2MVWRjhrLHaX28SHFky 270190501490895327846
These are found in the same second and it keeps this behavior.
This behavior made me crazy guys. I do not understand how it can do this.
Do you have a binary to search vanity which runs on Silicon CPUs? I could not find any nor make it work, a lot of libraries are only for intel.
Could you share it ?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
@Tepan
Can you explain a little bit more your formula ?
Can you explain a little bit more your formula ?
First thing first it's funny someone really spend their time to this like Mr.AKITO.
I want to explain but I'm afraid of appearing smarter than my friends who are great at spending their time creating and ensuring programs like search using the hash of public key 160 and even compressed public keys, will feel offensive to them, this is just my thoughts for 2 years paying more attention to this forum and puzzle.
but okay if you want to.
old_key = 4563 -- was from "95823/21" 21 is divided by count the 95823 into 2097151, have 2 option 22 or 21, 21 is precisely with target.
old_range = (65536, 131071)
new_range = (1048576, 2097151)
result :
[1245699, 1660932, 2076165, 1400841, 1816074, 1140750, 1555983, 1971216, 1295892, 1711125, 1451034, 1866267, 1190943, 1606176, 2021409, 1346085, 1761318, 1085994, 1501227, 1916460, 1241136, 1656369, 2071602, 1396278, 1811511, 1136187, 1551420, 1966653, 1291329, 1706562, 1446471, 1861704, 1186380, 1601613, 2016846, 1341522, 1756755, 1081431, 1496664, 1911897, 1236573, 1651806, 2067039, 1391715, 1806948, 1131624, 1546857, 1962090, 1286766, 1701999, 1441908, 1857141, 1181817, 1597050, 2012283, 1336959, 1752192, 1076868, 1492101, 1907334, 1232010, 1647243, 2062476, 1387152, 1802385, 1127061, 1542294, 1957527, 1282203, 1697436, 1437345, 1852578, 1177254, 1592487, 2007720, 1332396, 1747629, 1072305, 1487538, 1902771, 1227447, 1642680, 2057913, 1382589, 1797822, 1122498, 1537731, 1952964, 1277640, 1692873, 1432782, 1848015, 1172691, 1587924, 2003157, 1327833, 1743066, 1067742, 1482975, 1898208, 1222884, 1638117, 2053350, 1378026, 1793259, 1117935, 1533168, 1948401, 1273077, 1688310, 1428219, 1843452, 1168128, 1583361, 1998594, 1323270, 1738503, 1063179, 1478412, 1893645, 1218321, 1633554, 2048787, 1373463, 1788696, 1113372, 1528605, 1943838, 1268514, 1683747, 1423656, 1838889, 1163565, 1578798, 1994031, 1318707, 1733940, 1058616, 1473849, 1889082, 1213758, 1628991, 2044224, 1368900, 1784133, 1108809, 1524042, 1939275, 1263951, 1679184, 2094417, 1419093, 1834326, 1159002, 1574235, 1989468, 1314144, 1729377, 1054053, 1469286, 1884519, 1209195, 1624428, 2039661, 1364337, 1779570, 1104246, 1519479, 1934712, 1259388, 1674621, 2089854, 1414530, 1829763, 1154439, 1569672, 1984905, 1309581, 1724814, 1049490, 1464723, 1879956, 1204632, 1619865, 2035098, 1359774, 1775007, 1099683, 1514916, 1930149, 1254825, 1670058, 2085291, 1409967, 1825200, 1149876, 1565109, 1980342, 1305018, 1720251, 1460160, 1875393, 1200069, 1615302, 2030535, 1355211, 1770444, 1095120, 1510353, 1925586, 1250262, 1665495, 2080728, 1405404, 1820637, 1145313, 1560546, 1975779, 1300455, 1715688, 1455597, 1870830, 1195506, 1610739, 2025972, 1350648, 1765881, 2097151, 1090557, 1505790, 1921023]
i mark that with red color, just because as you can see, it's nearly with real decimal value to search, i test it with 10-20 puzzle, there is always a very close result, but need to search and wait for time.
for someone if ask how you can determine the first search is 1811764
in real condition with my codes is marked into hex, and groupped for search ranges, so it's from small value to larger value, and sequence ranges but random search on ranges.
searching puzzle #21 key 1BA534 > 1811764.
[...snip...]
@Tepan I still dont understand the sequence of values. Are just random values? Or are they following a pattern using the number old_key = 4563 ?
Also you select the red number based on the private key of the puzzle 21 so... what if you dont know it ?
I'm just trying to make sense to your message and trying to replicate to other puzzles
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Someone has to sit down and write a completely new kangaroo.
Shouldn't we be looking at FPGAs by now?
I'm actually working on a little project to get me started with Verilog.
It is a simple xpoint-only bruteforcer for now. The design works fine, but I couldn't fit it on the target chip yet.
The main goal is to get to the level where I can create a HDL Kangaroo implementation as there are none out there.
I agree with you. I think the future is the FPGA, it is the clear evolution path.
Re: == Bitcoin challenge transaction: ~1000 BTC total bounty to solvers! ==UPDATED==
I think the owner of this Puzzle just moved 13 btc from puzzle #130 to his wallet, the one ending with YESs
No did not move anything. I think it was solved by the same guy as 120,125...
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Do you still have doubts that it wasn't this person who decided https://bitcointalk.org/index.php?topic=1306983.msg51803085#msg51803085
https://bitcointalk.org/index.php?topic=5218972.msg62181304#msg62181304
With 8x Tesla A100 ? I have 6 in my lab. I haven't found anything so far. It's not just about the GPUs here.
Something else is happening here.
Maybe he/she is just a brilliant mind...and that person knows a way to reuse the DPs from 120,125 to find 130 and the rest.
I would like to know how he/she did it !
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
@Tepan
Can you explain a little bit more your formula ?
Can you explain a little bit more your formula ?
[...snipped...]
Thanks for explaining it but i dont get what is the number 95823 from your first line
Code:
old_key = 4563 -- was from "95823/21"
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I've been trying to solve puzzle 130 for two years now. 6 GPUs. The puzzle creator is kidding with us. Yes, we are all donkeys. 
Oh man that sucks big time! Sorry. I have similar situation... Not two years tho..
@Tepan
Can you explain a little bit more your formula ?
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Puzzle 130: ~ [Expected Hops: 2^65.64 (57392798431464251392)]
How much storage is needed to precompute Puzzle 130 ?
How much storage is needed to precompute Puzzle 130 ?
1. That number is kind of a reference point, can vary ± 20% Besides, the best known complexity is rather 1.66 * sqrt(b) but requires special attention when jumping through the point at infinity. Speed is better when we're certain we'll never need to double a point or go through O, since that special branch goes away..
2. It's non-sense to precompute stuff when you know all the variables. It's just faster to solve the problem. Pre-computation makes sense to search and save traps inside the same space where the wild kangaroos will jump around.
You don't need any storage to solve 130 or 160 or 66 or 250+ bits. Storage is only needed if DP > 0 or if you have more than a single Tame and Wild kangaroo. But since we don't have forever to do all those gazillion ops, the catch is to compute a lot of kangaroos in parallel - as we definitely can't compute just two kangaroos in parallel, the next jump depends on their current value.
So storage depends on whatever you wish to accomplish. Might as well just save an ID of the kangaroo that reached a DP, and re-create the walk when a match occurs, to get the distance. But it's slow if the walk was a long one.
Pre-compute is just running all "tames"... (k*g) through whatever range and store the points (public key x points, not the whole thing but however many bits you chose (not to few though or then you have false collisions)) That's all pre-computing really is. Same as BSGS, 1*g all the way up to however many points you want in your baby step file. And all of those points are DP 0.
For the 130 puzzle, we are using DP 32. So we will roughly need to find 2^33.55 distinguished points. File size, should be right around 400GB; that's my estimate.
And albert0, since you know BSGS better than most, a 100,000 view way to look at Kangaroo, consider the baby step file the tame kangaroos, and the giant steps, the wilds (offsets). BSGS is like a brute force mixed with Kangaroo lol. But Kangaroo is just more spread out with it's jumps, whereas BSGS takes the exact same "step" each time. Kangaroo creates multiple offset pubkeys (addition or subtraction or both), those are the wilds. And once one of those offset points matches a tame point, basic math just like BSGS.
Tames are just k*g, with some distinguishable point. The 130 pool, DP 32, so we save every x point that has at least 8 zeros at the end (trailing). The wilds are k*g + public key, that you are searching for. Same thing, if it ends with 8 zeros, it gets stored. Once we get a collision / match, we merely take the tame distance (k*g or private key really) and subtract the wild distance. And like BSGS, if you reduced the range by subtracting the start range up front, then you have to add it back. (tame distance - wild distance) + initial subtracted start range.
Very nice and clear explanation about the kangaroo and BSGS methods. Cheers WanderingPhilospher!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
https://i.ibb.co/tDW6Sxr/2024-08-19-14-18-12-740-electrum-4-5-5-portable.png
Waiting for someone to help me move the balance without losing it.
Waiting for someone to help me move the balance without losing it.
Wait a moment! the total amount is not correct. This is probably fake....
