I solved..

It is impossible once the transaction started in any case. Transaction should not fail, that's why I explained you must pay high gas prices.

best way is sending via script and send with buffer. for example, for 6.7 BTC send 6.6, let gas get highest.


<sup>from bitcoinlib.wallets import Wallet
from bitcoinlib.transactions import Transaction

# Private key
private_key = '?'

# Create a wallet object
wallet = Wallet.create('wallet123')

# Import the private key into the wallet
wallet.import_key(private_key)

# The recipient's address and the amount to send (in satoshis)
to_address = 'bc1qh268pwph4uuf256wlfknwucg3e8v2jl7cgzq65'
amount = 660000000
print("Wallet Balance:", wallet.balance())

# Create a transaction
tx = wallet.send_to(to_address, amount)

# Print the transaction ID
print("Transaction ID:", tx.txid)</sup>

Nope, carefully review this address "bc1qh268pwph4uuf256wlfknwucg3e8v2jl7cgzq65", 6.7 BTC will be there soon.

Okay, I understand you are all supporters of Bitcoin and Cryptocurrency.

However, the founders of Bitcoin died, most of them got killed.

I understand you, your point of view. However you do not understand me. I am here to help the people who do not know anything and using Bitcoin just for investment by their money to save their money before Bitcoin and Cryptocurrency era done.

I just wanted to try people to understand the leak and see with their own eyes, and smooth transition so not much people get hurt.

But what I understand from your writings, you will never understand what I am talking about and you will keep being in an illusion and living your being rich dreams.

Okay, let me tell you what I will do to you to understand me is not coming with new cryptocurrency of course

I will move the whole balance from the Genesis Block of Satoshi with the address "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" to another wallet soon.

So then, may be you can understand what is going here, what I am trying to tell you on and how the world will get affected.

@Wapfika

Okay, I hope no one adds a new reply here. This is the best reply I expected.

I will edit this message very soon. I never had "butthurt" in my life, I do not even see a person who has that, I hope you have notable amount of Bitcoin investments, I will see and learn what the "butthurt" thing really is in your next reply

If you are looking an early adapter, I am the one here, however almost all early adapters got killed including Satoshi by those "Bad People".

However, I am not Satoshi or them, not that easy to destroy, that's why I came here with open Ip and Mac.

@Lucius

What I can say and admit is, just store some gold, real, physical gold. Do not even trust money and current banking system where many of them also rely on cryptography fables.

@Lucius

I am in 40s. I do not have dad or mom and their money to spend. I do not have anyone or anything. I am not a leader though, never would be and never want to be. There is no first or last cryptocurrency, they all rely on a single cryptography, ECC.

I am here to warn all of you, we are so close to the era where these Cryptocurrency will be gone from our lives. I am here to save your money so you can spend it for yourself and your family rather than making "Bad People" rich with your money.

You will see and understand me soon, just save your money, and use it for your good.

 

@bitmover, @SilverCryptoBullet

I always believe in math. That's why I am saying that, ECC will be broken one day (already broken by some groups and we are just researching yet to find out how)

But before coming to ECC and Quantum Computing, if you think today's random methods really generates your private key in the range between 1 and 2^256, you do not understand the material of computers, how the volt hits and generates those 1's and 0's.

Even today's private keys are generated in very small ranges, you can generate 1 quadrillion private key from 100 different devices, plot them on a graph, you will understand what I am talking about.

@EluguHcman

I am not saying all people investing Bitcoin are bad people. Bitcoin has born against the financial control, I gave a big support to the team in the beginning. However, owners of the most of the rich bitcoin wallets are drug dealers, hitmen / hitmen agencies, terrorist groups like ISIS who kidnapped people, did torcher, raped little babies on Commander / Viewer rooms etc.

So, whenever Bitcoin price increases, if you earn 1 dollar, they earn millions. Not the 50% people, the 50% of Bitcoins.

From 2012s, I am on the side against the Bitcoin while I was supporting Bitcoin until then.

Someday, we will reach the era where Bitcoin goes down to 0$. However, it will be chaos then someone or some groups control everything in the world. So you can understand why I hurry, why I keep fighting..

If we damage today, as people, even some group on day take the control via Quantum Computing, it won't harm through a damaged cryptography and system, people will understand and had the experience and definitely there won't be much to control for them. However, if they gain this fight, you can not imagine the world how it will be..

Most probably mods will block this message.

You know systems like "All Private Keys are here" etc.

I always hate Bitcoin, I always did hate. I know Bitcoin from the first day, I have Hal's private key in my hand, I spent a lot of years to break ECC etc. (Just one single point behavioral issue problem left, then it will be ready, I shared article about this, but no one understands that level of math, and no one cares actually)

Because, you all are just pawns to make bad people rich. More than 50% of the money in Bitcoin belongs to those "Bad People".

It is definitely not safe, no can say ECC is safe while in 2008 NSA already broke it and after they came with Double ECC lie. All private keys are just a number between 1 and 2^256, it can be hard today, but few years ago 2^64 was like that, you remember. Currently graphic cards are processing quadrillions of data in milliseconds, I do not mention about how fast Quantum Computing is evolving. So it will be sooner or later goes down to 0$.

However I do not have time to wait, because years and years I fought with those "Bad People". I just built a small page, randomly generates a private key and checks all related addresses' balances. If I run this on hundreds of containers, I do not think it will be effective, but I always believed crowd effect. If millions of people run this on hundreds of containers, I am not saying we can extract all private keys, however I believe that we can extract very considerable wallets with millions of dollars and we can manage to damage this sh*tCoin.

You can remove my message, you can ban me, but I won't stop.

https://btchunthere.github.io

We are not able to reach him after this message, he also deleted his Github and Telegram. Let me try to explain, it is not hard and very known discrete logarithm problem in ECC that he stuck. I am also working on this code block more than 2 years. This code block is a bit buggy version actually for example in for loop, the end case is set as G, but it is not adding +1 so when this code block identifies the private key this assertion will always fail "assert PK == PKV".

Anyway, ECC is build on "Double and Add" in behind, and the reverse algorithm idea is "Subtract and Halve". Let's say you have a private key 11, which is "1011" in bit level. How elliptic curve generates public key from this bit is:
Initial = 0G
For 1, algorithm is Double and Add
For 0, just Double


1 -> Double and Add -> 0G * 2 + G = G
0 -> Just Double -> G * 2 = 2G
1 -> Double and Add -> 2G * 2 + G = 5G
1 -> Double and Add -> 5G * 2 + G = 11G

This is how Elliptic Curve generates your public key from the private key. So, what this guy was saying is, it can be reversible by "Subtract and Halve" then. How it will be:

You have the Curve order, which is 115792089237316195423570985008687907852837564279074904382605163141518161494337 for SECP256k1.
And the when you apply modular inverse for "2", it will give 57896044618658097711785492504343953926418782139537452191302581570759080747169, which means if you multiply a point by this number, it will give you the Halved point. So Elliptic Curve is using "Scalar Multiplication" while "Double and Add", and you can use this number for "Scalar Division" while "Subtract and Halve".

How "Subtract and Halve" will be applied, you must know if the Point is "Odd" or "Even". To understand this, let's deep dive. For example in our case the point is 11G, when you halve it, it will give you 5.5G. How elliptic curve handles this fractional number is, it is doing this:
5G + (Half Order G, which is 57896044618658097711785492504343953926418782139537452191302581570759080747169G). So when you halve the point, if it is Odd, the point will go to the left side of the curve, which means after the half point, greater than the half point. If it is even, the result will be just 5G, which will be on the right side of the curve, which means before the half point, lower than the half point. The stuck point is here. We as a team, tried several ways to understand the behavior of a point, how a point behave when it is on left side or right side. However, even our trained AI which we trained with Quadrillions of Points data not clearly identified the point position. However, if you are able to manage this, there won't be any discrete logarithmic problem in Elliptic Curve, which means you will be able to extract the Private Key from any Public Key.

How it will be?
You have X G, you do not know it is 11:
X G -> Halve -> 5.5G -> So the 5.5G point will be on the left side of the curve (assume you managed to identify this) -> Go back to initial point and just apply Subtract and Halve.

11G -> Subtract and Halve -> (11G - G) / 2 -> 5G -> Save the bit as "1" because the operation is "Subtract and Halve"

Now apply the same for 5G, it is also Odd, and when you halve it, you will get 2.5 G, so you must apply again Subtract and Halve:

5G -> Subtract and Halve -> (5G - G) / 2 -> 2G -> Save the bit as "1" because the operation is "Subtract and Halve"

Now apply the same for 2G point, now this is Even point is on right side of the curve, so you should apply just "Halve"

2G -> Halve -> 2G / 2 -> G  -> Save the bit as "0" because the operation is "Just Halve"

So in the and you have just "G", where this code will stop here "if NEXT == get_first_point(): break" This part of code is wrong. It must stop on Infinity, which means "0G", not on G (the first point).

So let me give you first the fixed parts of code:

<sub>def get_point_infinity():
    return Point(SECP256k1.curve,
                 None,
                 None)

and change here:
if NEXT == get_point_infinity():</sub>


Now this code will continue, what we had left, "G", apply the same for G, it is also Odd, and when you halve it, you will get 0.5 G, so you must apply again Subtract and Halve
G -> Subtract and Halve -> (G - G) / 2 -> INFINITY -> Save the bit as "1" because the operation is "Subtract and Halve"

and now your code will be stopped running. Lets collect all here:
11G -> Subtract and Halve -> (11G - G) / 2 -> 5G -> 1
5G -> Subtract and Halve -> (5G - G) / 2 -> 2G -> 1
2G -> Halve -> 2G / 2 -> G  -> 0
G -> Subtract and Halve -> (G - G) / 2 -> INFINITY -> 1

What was our private key "1011", and look up, what you see there?

Thanks mamuu, this was my first thought that Satoshi generated those public keys and put $72 Billion in them without knowing private keys.
However, would anyone do that? I would not. I would prefer to design a game on math, rather than design a game on randomness.
But, of course, this can be an option too.

Btw, for an update, this formula "(P * (P^m-2 % m)) % m" lost its validity after several tests. So, my new approach is to identify if point is on the left or right side of the curve, which means P > Half Curve Point (57896044618658097711785492504343953926418782139537452191302581570759080747169) or P < Half Curve Point. Because if the point is Odd, when you apply halve on the point, halved P will be greater than curve half point ALWAYS. However if it is Even and when you apply halve, the halved P will be lower than curve half point ALWAYS. I am now training an AI to identify this, do not have success yet, and searching the ways to identify if point P is greater or lower than the curve half.

<sup>p = 6
pubkey = bitcoi[Suspicious link removed]ivkey_to_pubkey(p)
P1 = Point(SECP256k1.curve,
           pubkey[0],
           pubkey[1])

p = 8
pubkey = bitcoi[Suspicious link removed]ivkey_to_pubkey(p)
P2 = Point(SECP256k1.curve,
           pubkey[0],
           pubkey[1])

p = 48
pubkey = bitcoi[Suspicious link removed]ivkey_to_pubkey(p)
P3 = Point(SECP256k1.curve,
           pubkey[0],
           pubkey[1])</sup>


As you can see these are 3 points. 3rd one is the multiplication of first two.
Now try this:

from sympy import symbols, Eq, solve

<sub>a, b = symbols('a b')

# Points
point1 = (53957576663012291606402345341061437133522758407718089353314528343643821967563,
          98386217607324929854432842186271083758341411730506808463586570492533445740059)
point2 = (72488970228380509287422715226575535698893157273063074627791787432852706183111,
          62070622898698443831883535403436258712770888294397026493185421712108624767191)
result_point = (27014530906007957169531703425481274912103442539779119437726046076907210423569,
                70052204206988426097199854494650803460514936258189950471015657998938191627469)

# Setting up the equations for linear combination
eq1 = Eq(a * point1[0] + b * point2[0], result_point[0])
eq2 = Eq(a * point1[1] + b * point2[1], result_point[1])

# Solving the equations
solution = solve((eq1, eq2), (a, b))
print(solution)</sub>


When you do another multiplication a and b will get change. Of course this won't be the formula it will be something like:

    _{m = ((c * point1.x() * point2.x()) + curve.a()) * \
        inverse_mod(2 * point1.y() * point2.y(), curve.p())
    x3 = (m * m - 2 * point1.x() * point2.x()) % curve.p()
    y3 = (m * (point1.x() * point2.x() - x3) - point1.y() * point2.y()) % curve.p()}


This is not the formula of course, I just copied and enhanced from point doubling, but something like this will give the point multiplication result for all cases. I hope you got my idea. Rather than discussing the possibility of some operations, we must start to think about realizing it because I can say that honestly I clearly see that can be done. And point exponent will be most probably the same as scalar multiplication, just we won't use point_add, we will use point_multiply by itself.

Thank you for your insights and the shared script. Firstly, the assertion that "we can not multiply a point by another point" in ECC is contextually accurate in the realm of today's cryptographic applications. However, we must remember that the field of mathematics and cryptography is in a constant state of evolution. What we "currently can not do" is precisely what paves the way for future breakthroughs. My work is dedicated to investigating these unexplored potentials.

By sharing my research on GitHub, I aim to open the doors to collaborative innovation, inviting others to join in pushing the boundaries of ECC. This is not just about challenging the status quo but about expanding our collective understanding and capabilities in cryptography.

Let’s continue to advance the field, keeping in mind that today's theoretical explorations could be the foundation of tomorrow's cryptographic realities.

Hi everyone,

I appreciate the feedback on the Python code shared in my GitHub repository. It's important to note that this code represents a collection of methods used during my research, rather than a fully functional program. Let me take a moment to explain the purpose behind it.

Understanding the Reverse of 'Double and Add' Method
In ECC, converting a Private Key to a Public Key typically involves the 'Double and Add' method. For instance, with a scalar of 10, represented in binary as "1010", the process on an elliptic curve would be:

1 (Double and Add) ➡ G
0 (Just Double) ➡ 2G
1 (Double and Add) ➡ 5G
0 (Just Double) ➡ 10G
What my code aims to achieve is the reverse of this process, which I term "Subtract and Halve."

Implementing 'Subtract and Halve'
To execute this, it's essential to determine if a point is odd or even, for which we need a modulo 2 operation. The formula "(P * (P^m-2 % m)) % m" is used here, where 'm' is the maximum value of the curve, a very large number in ECC.

When we apply this operation to a public key point 'P' on an elliptic curve, we obtain either point 1 or infinity (zero). If it returns point 1, this implies our last binary digit is 1, indicating we should set one and apply 'Subtract and Halve'. If it returns infinity, the point is even, and we apply just 'Halve'.

For example:

10G (Even) ➡ Just Halve ➡ 10G / 2 ➡ 0
5G (Odd) ➡ Subtract and Halve ➡ (5G - G) / 2 ➡ 1
2G (Even) ➡ Just Halve ➡ 2G / 2 ➡ 0
G (Odd) ➡ Subtract and Halve ➡ G - G ➡ 1
This process ultimately leads us back to the original private key, in this case, 1010.

The Core Challenge:
The main issue in my research is the accurate implementation of "point_exponent" and "point_multiplication." If these could be properly executed, it would have groundbreaking implications for ECC and internet security as a whole. My initial question, which sparked this exhaustive research, was inspired by the distribution of Satoshi's public keys on the elliptic curve. The hypothesis is that Satoshi might have already implemented this back in 2009.

In a bid to keep my research and efforts transparent and accessible, I have decided to share the GitHub repository containing my work on elliptic curve cryptography (ECC). Here's the link to the repository:
https://github.com/ecc-r/ECC-Vulnerability-Research

This journey into the depths of ECC has been more than just academic for me. It's been a path filled with personal and professional challenges. I've always believed in the power of open source, not just as a methodology for development but as a way to collaborate and uncover truths that could redefine our understanding of security in the digital age.

The work focuses on the potential of multiplying two points on an elliptic curve and efficiently calculating the exponent of a point. If these methods can be realized, they could have profound implications for the security of internet cryptography as we know it.

As someone who has lost much in the pursuit of this research, this project is more than just code and theory; it's a part of me. Any input, insights, or collaboration from the community would not only be appreciated but could also be pivotal in achieving a breakthrough in this challenging field.

And finally, hey Satoshi, are you there?

Alright, let's delve into the details. First off, here's the CSV I shared, starting with the first 10 public keys:


<sup>040000356cb2e0d0c0a0167693b14c338f548da20fea024a04449907140fa270ebff37ae70d00db 8137b5c60d9563b743b090f162f7bf1b51650d20cd7022d695d

04000136bd8d133189ca0e40334a05ac1ce1d33e992f8628a582ec6a27757d0338e1ec3c25631a3 55abec4f8cd452897f7383caa36123ddd232ffb2e9cf48a2806

040001c5a1d394656166be6c0d41219ed3bba0b2b4dd38d0c0f317b6ad0c491ffca489d30ae9177 3b16626a70752f785284840a3e679c86d0bd42ff1bbb47311f1

04000272b300286c7870642be993dd7189a7dd4f713ad133cb04a36f5560dd28ef9782ac421aaec 692650b74f987d42b8330d0af8370799b808644c18aab68ea6f

040005929d4eb70647483f96782be615f7b72f89f02996621b0d792fd3edd20dc229a99dfe63582 d5471b55bcbb1d96c6e770ea406ce03bc798dc714bab36d5740

040009f1f66d83cfe7ec07d8abbd3b85004ff5fe9fe0145e7e85048158284bcb6e9a154fd2a831a f881e55efda58542e00b06a6c1a47f98a04270db2c4faf505b5

04000b1c8a00b4543af5c6121411796e2f02d7d09a57341d85544a06e0c2311b62f2bb2f4279f4a b8ee3d6e1b98d3905ff2808a5f9d05429ff2e4d1f7edae95dda

04000d82179bdc0fdfd4c8f7b46e7bea3a84c35dbaacaee3f35193213728fb4afdac18a09151c36 d7d16e8b72851e90e7ad4c247ac8ae734a3ce096cb354daf2c0

04000ed8229b6fc925fe164bd5be916efab02fb00941dedda712442c145448093995298badfde68 e994f786eb41ea5056bb9f2e3e7d24eb18d383ea35dca49b141

04000f5b05655898aec1744b699dbc461015b714082b19683f495fbc3d24db30b79d76cf773e768 35513d25fbf78d7e82cf47fbb9249faede77be5d290456a5f30

0400159fa21fc72ebf88b9bfbcb7ed7c3c2daf1f3b86231a43354f342de2e16dfaf112dd5c62e71 e26717632c37191b105757026962caf9857de050aa732d1b354</sup>


These keys are in sequential order, continuing up to 04ffffcdeee179409d5b0e3133929d6c1292d57768182e650878304dc6867e7a0b0f14b11d08932 8382dcc962312d22fe148b01c8ff911bff70af274146fb000e3.

I've experimented with various methods to crack the elliptic curve, such as point shifting, halving, and examining negative points, but so far, none have yielded significant results. My latest approach involves modular operations: for a point with an odd mod 2, I perform point subtraction followed by halving; for an even mod 2, just halving. The challenge is in the mod 2 calculation, which involves raising the point to the power of 115792089237316195423570985008687907852837564279074904382605163141518161494335, then multiplying the point by this exponent result. This is based on the formula (P * (P^m-2 % m)) % m, where m is the maximum curve value 115792089237316195423570985008687907852837564279074904382605163141518161494337.

I've also tried replicating Satoshi's method of generating public keys in a mathematical sequence but haven't been successful. I'm essentially trying to decipher his thought process, the path he took, and his vision behind this particular order of keys.

Here is the data behind:

https://file.io/yG3ub34oQqTB

And the model on the elliptic curve, I saw the same model in telecom business from the image of public key distribution on elliptic curve, and to parse the relative data from this model, the middle of each clusters were targeted.

Satoshi might have some background from Ericson kind telecom companies

I deep dive in Elliptic Curve more than years.
Because I do not like the way of using this curve everywhere. Currently it seems like safe, however, as we all know, time and technology always defeat cryptography.

Anyway, when I collected satoshi's public key, put them on a curve and clustered.
There seems a pattern:
https://ibb.co/zrsDy6c

And the public keys are generated by an order on X axis and the Y axis is matching those X axis, so it generates a shape on the curve.
This made me crazy, because it is kind of impossible to generate public keys in this perfect order on the curve. (or if it is possible someone should tell because I investigated a lot and could not find anything)

Several thoughts came into my mind:
- Might Satoshi already break the Elliptic Curve in 2009?
- And might this be a puzzle waiting someone to solve?

These public keys worth $72B today..