I made my own code to Create your own Bitcoin address (Python)

[nc50lc]

i'm just curious why I need to create my own Bitcoin address instead of using the ones generated by Electrum.

The difference is minimal whether you know python or not.

In a scenario where the user knows how to read python, then he don't have to involve trust on using Electrum if you verify its seed-generation and address derivation code.
The only benefit that I can see is this is just a few lines of code that's easily auditable within a few minutes compared to Electrum's code (excluding the imported libraries)
Although overall, in the end, a power-user will know how secure the entropy used and if the address is correctly generated.

But in a scenario where the user is just an average joe, he can verify neither, then there's no tiny benefit on using OP's script in that case.
And since that advantage is about convenience, it's the opposite even since a non-tech savvy user will find it hard to run a python script rather than using a wallet with GUI.

-snip-

Try to enclose your script between [code][/code] tags.
Reason is: The forum might break its formatting, specially long strings and it's quite hard to copy.
Also, some people could have trouble differentiating which are the parts of the script from the notes of your post.

[NotATether]

I stopped using plain Python to generate seed phrases or private keys because it's so easier to mess up and accidentally save the private data in the command history, or output it somewhere.

Private keys and stuff need extreme care during generation, if they are even cached in one place then you lose. To be honest, only experts who know the internals of Python can defend against all these situations, which is why it's much better to use a low level language like C for this purpose.

[13rianx@gmail.com]

 this is not necessary there are literally hundreds and hundreds of scripts and programs already , try python index     https://pypi.org.  or use bit. its  about 10 lines and generates  addresses   ie               .                                                                                                                                                                                                                                                                         from bit import Key
from bit.format import bytes_to_wif

def AddressMaker(n):
    # Ensure input is integer (handles both int and str)
    private_key_int = int(n)
    private_key_bytes = private_key_int.to_bytes(32, byteorder='big')

    # Compressed address
    key_compressed = Key.from_bytes(private_key_bytes)

       # Return both addresses
    return {
          key_compressed.address
    }

# Example usage:
result = AddressMaker(5)
print( result)

[shinohai]

this is not necessary there are literally hundreds and hundreds of scripts and programs already , try python index     https://pypi.org.  or use bit. its  about 10 lines and generates  addresses   ie               .                                                                                                                                                                                                                                                                         from bit import Key
from bit.format import bytes_to_wif

def AddressMaker(n):
    # Ensure input is integer (handles both int and str)
    private_key_int = int(n)
    private_key_bytes = private_key_int.to_bytes(32, byteorder='big')

    # Compressed address
    key_compressed = Key.from_bytes(private_key_bytes)

       # Return both addresses
    return {
          key_compressed.address
    }

# Example usage:
result = AddressMaker(5)
print( result)

^ This, and it's far better than 5`394 lines of AI slop.

[Phobos_Quake]

this is not necessary there are literally hundreds and hundreds of scripts and programs already , try python index     https://pypi.org.  or use bit. its  about 10 lines and generates  addresses   ie               .                                                                                                                                                                                                                                                                         from bit import Key
from bit.format import bytes_to_wif

def AddressMaker(n):
    # Ensure input is integer (handles both int and str)
    private_key_int = int(n)
    private_key_bytes = private_key_int.to_bytes(32, byteorder='big')

    # Compressed address
    key_compressed = Key.from_bytes(private_key_bytes)

       # Return both addresses
    return {
          key_compressed.address
    }

# Example usage:
result = AddressMaker(5)
print( result)

That creates a P2PKH key. A bit outdated And I want to have control over the entropy.

[NotATether]

That creates a P2PKH key. A bit outdated And I want to have control over the entropy.

Most address generation programs and wallets are all sourcing entropy from either /dev/random or /dev/urandom, which generates pseudorandom bytes after true randomness is exhausted.

Deriving statistically random bytes from a given input source is quite tricky, let alone combining bytes from different sources, so that's why you don't see many implementations of anything using non-standard random sources.

[Phobos_Quake]

That creates a P2PKH key. A bit outdated And I want to have control over the entropy.

Most address generation programs and wallets are all sourcing entropy from either /dev/random or /dev/urandom, which generates pseudorandom bytes after true randomness is exhausted.

Deriving statistically random bytes from a given input source is quite tricky, let alone combining bytes from different sources, so that's why you don't see many implementations of anything using non-standard random sources.

Correct.
There has been an instance of a wallet getting hacked because they were using random from a library, the hackers figured out how the library generates the entropy.

This isn't a problem with the entropy that uses random factors from your computer data, RAM,etc unless your computer is compromised looking at the random generator.

But again, it's not that I don't trust how randomness is done nowadays. It's about not knowing what entropy some wallets are using. I know you can tell by looking at open-source code, but who does that?
I just wanted to have my own method and entropy where I know where the vulnerabilities lie.