Quote from: kalos15btc on September 13, 2023, 09:53:17 PM

Quote from: Dexed on September 12, 2023, 08:21:56 PM

Quote from: BurtW on June 08, 2019, 03:11:23 PM

Quote from: mrxtraf on June 08, 2019, 11:49:04 AM

By the way, and you know why their puzzle addresses were removed from the 161st?
My thought is that this is the limit of public addresses. That is the further search in the theory goes on a circle.

Because all the funds from 161 through 255 were redundant (Bitcoin addresses only use 160 bits) the author of the puzzle moved all the funds from the 160-255 ranged down into the 1-160 range. It is explained up thread.

Is it? I thought it uses almost 256 bits (the last possible private key is FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140)

OH, HIII, Good morning

Quote from: digaran on September 12, 2023, 10:20:10 PM

Quote from: lordfrs on September 03, 2023, 09:10:50 AM

Quote from: digaran on September 02, 2023, 10:45:02 AM

Quote from: mcdouglasx on August 20, 2023, 02:30:52 PM

Code:

from sympy import mod_inverse
import secp256k1 as ice
pub=ice.pub2upub('Here Compressed Public Key')
N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

k=mod_inverse(2,N)
neg1=ice.point_negation(ice.scalar_multiplication(1))

def ters(Qx,Scalar):
   ScalarBin = str(bin(Scalar))[2:]
   le=len(ScalarBin)
   for i in range (1,le+1):
   if ScalarBin[le-i] == "0":
   Qx=ice.point_multiplication(k,Qx)
   else:
   Qx=ice.point_addition(Qx,neg1)
   Qx=ice.point_multiplication(k,Qx)
   return ice.point_to_cpub(Qx)

for x in range(1,65536):
   f= (ters(pub,x))
   data= open(“halfpub.txt”,”a”)
   data.write(f+”\n”)
   data.close()

Note this is where you decide how many bits should be reduced
for x in range(1,65536):
For example reducing 26 bits requires 67108864 to be generated, 1 of them is the correct 26 bit reduced key.

Will you release for public to use?

Yes this is my code, I can write bit reduction code in another way if you want. If you want, you can reduce bits by subtraction.

I'm developing a new algorithm for downgrading from a known bit range to the bit range I want. When I complete it by giving only 1 correct pubkey, I will share it here.

@lordfrs, I was thinking, why do we need to keep all the 65556 keys if we are reducing 16 bits? One other thing, if we multiply one of the keys from the end of the output file by 65556 we should see our target, correct? I haven't thought about on how to calculate, since we are subtracting one dividing by 2, one result if multiplied by 2^16 should reach the target or close to target, so why not discarding 90% of the generated keys and start multiplying the remaining 10% by 2^16? Could you add such operation to your script?

I guess if we could operate on private keys instead of public keys using your script, we could reach some results, ( as a test of course )

To test with scalar only, I use this script :

Code:

from sympy import mod_inverse
N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

def ters(scalar):
k = mod_inverse(2, N)
scalar_bin = bin(scalar)[2:

bro please stop replying with those comments copy past from chatgpt you are doing nothing except replying and talk too much, you are doing nothing for real men, stop it bro, :) thank you
[/quote]

He is learning maths and programming, so I think is not a este of time..

Hello to everyone