பைதான் உடன் ஒரு கிரிப்டோகரன்சி வாலட்டை உருவாக்குதல்: ஒரு விரிவான வழிகாட்டி

டிஜிட்டல் நிதி உலகின் வேகமாக மாறிவரும் சூழலில், கிரிப்டோகரன்சிகள் ஒரு புரட்சிகரமான சக்தியாக உருவெடுத்துள்ளன. இந்தப் புரட்சியின் மையத்தில் ஒரு வாலட் என்ற கருத்து உள்ளது—பிளாக்செயின் நெட்வொர்க்குகளுடன் நீங்கள் தொடர்பு கொள்ளும் உங்கள் தனிப்பட்ட வாயில். பல வணிக வாலட்கள் இருந்தாலும், அவை எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்துகொள்வது எந்த டெவலப்பர் அல்லது தொழில்நுட்ப ஆர்வலருக்கும் ஒரு விலைமதிப்பற்ற திறமையாகும். இந்த வழிகாட்டி பைதான் பயன்படுத்தி புதிதாக ஒரு செயல்பாட்டு கிரிப்டோகரன்சி வாலட்டை உருவாக்குவதன் மூலம் செயல்முறையை எளிதாக்கும்.

அடிப்படை கிரிப்டோகிராஃபிக் கோட்பாடுகள், அத்தியாவசிய பைதான் நூலகங்கள் மற்றும் பிட்காயின் மற்றும் எத்திரியம் இரண்டிற்கும் விசைகளை உருவாக்குதல், முகவரிகளை உருவாக்குதல் மற்றும் பரிவர்த்தனைகளில் கையொப்பமிடுதல் ஆகியவற்றிற்கான படிப்படியான செயல்படுத்தலை நாங்கள் உள்ளடக்குவோம். இந்தக் கட்டுரையின் முடிவில், வாலட் இயக்கவியலைப் பற்றிய ஒரு திடமான புரிதலையும், உங்களுக்கென ஒரு செயல்பாட்டு கட்டளை வரி வாலட்டையும் நீங்கள் பெற்றிருப்பீர்கள்.

பொறுப்புத்துறப்பு: இந்த வழிகாட்டியில் வழங்கப்பட்டுள்ள குறியீடு மற்றும் கருத்துக்கள் கல்வி நோக்கங்களுக்காக மட்டுமே. ஒரு உற்பத்தித் தர வாலட்டை உருவாக்குவதற்கு கடுமையான பாதுகாப்பு தணிக்கைகள், விரிவான சோதனைகள் மற்றும் மேம்பட்ட பாதுகாப்பு நடவடிக்கைகள் தேவை. நிஜமான நிதியைச் சேமிக்க இங்கே உருவாக்கப்பட்ட வாலட்டைப் பயன்படுத்த வேண்டாம்.

ஒரு கிரிப்டோகரன்சி வாலட்டின் முக்கிய கருத்துக்களைப் புரிந்துகொள்வது

ஒற்றை வரி குறியீட்டை எழுதுவதற்கு முன், ஒரு கிரிப்டோகரன்சி வாலட் உண்மையில் என்ன என்பதைப் புரிந்துகொள்வது மிக முக்கியம். அதன் பெயருக்கு மாறாக, ஒரு வாலட் உங்கள் நாணயங்களை "சேமிக்காது". உங்கள் கிரிப்டோகரன்சி ஒரு விநியோகிக்கப்பட்ட பேரேட்டில்—பிளாக்செயினில் பதிவுகளாக உள்ளது. ஒரு வாலட் என்பது உங்கள் சொத்துக்களின் மீது உங்களுக்கு உரிமையையும் கட்டுப்பாட்டையும் வழங்கும் கிரிப்டோகிராஃபிக் சாவிகளை நிர்வகிக்கும் ஒரு மென்பொருள் ஆகும்.

எந்தவொரு கட்டுப்பாடற்ற வாலட்டின் முதன்மை கூறுகள்:

1. தனிப்பட்ட சாவிகள் (Private Keys): உங்கள் டிஜிட்டல் ரகசியம்

ஒரு தனிப்பட்ட சாவி என்பது உங்கள் வாலட்டில் உள்ள மிக முக்கியமான தகவல். இது ஒரு மிக பெரிய, சீரற்ற முறையில் உருவாக்கப்பட்ட எண், ரகசியமாக வைக்கப்பட்டு உங்களுக்கு மட்டுமே தெரியும். அதன் நோக்கம் ஒரு டிஜிட்டல் கையொப்பத்தை உருவாக்குவது, இது நீங்கள் ஒரு பரிவர்த்தனைக்கு அங்கீகாரம் அளித்துள்ளீர்கள் என்பதற்கான மறுக்க முடியாத ஆதாரமாக செயல்படுகிறது. உங்கள் தனிப்பட்ட சாவியை நீங்கள் இழந்தால், உங்கள் நிதிகளுக்கான அணுகலை என்றென்றும் இழந்துவிடுவீர்கள். வேறு யாராவது அதை அணுகினால், அவர்களுக்கு உங்கள் நிதிகளின் மீது முழு கட்டுப்பாடு இருக்கும்.

• உவமை: ஒரு தனிப்பட்ட சாவியை உங்கள் டிஜிட்டல் பெட்டகத்தின் மாஸ்டர் சாவி என்று நினைத்துக் கொள்ளுங்கள். இது பெட்டகத்தைத் திறந்து அதன் உள்ளடக்கங்களை நகர்த்த அங்கீகரிக்க முடியும்.

2. பொது சாவிகள் (Public Keys): உங்கள் பகிரக்கூடிய அடையாளங்காட்டி

ஒரு பொது சாவி என்பது எலிப்டிக் கர்வ் கிரிப்டோகிராபி (ECC) எனப்படும் ஒரு வழி கிரிப்டோகிராஃபிக் செயல்பாட்டைப் பயன்படுத்தி உங்கள் தனிப்பட்ட சாவியிலிருந்து கணித ரீதியாக பெறப்படுகிறது. ஒரு தனிப்பட்ட சாவியிலிருந்து ஒரு பொது சாவியை உருவாக்குவது சாத்தியம் என்றாலும், மறுதலையாகச் செய்வது கணக்கீட்டு ரீதியாக சாத்தியமற்றது. இந்த ஒரு வழி உறவு கிரிப்டோகரன்சி பாதுகாப்பின் அடிப்படையாகும்.

• உவமை: ஒரு பொது சாவி உங்கள் வங்கி கணக்கு எண் போன்றது. மற்றவர்கள் உங்களுக்கு பணம் அனுப்ப நீங்கள் அதைப் பகிரலாம், ஆனால் அது அவர்களுக்கு நிதியை எடுக்கக்கூடிய திறனை வழங்காது.

3. முகவரிகள் (Addresses): உங்கள் பொது இலக்கு

ஒரு வாலட் முகவரி என்பது உங்கள் பொது சாவியின் ஒரு சிறிய, பயனர் நட்பு பிரதிநிதித்துவம். இது பொது சாவிக்கு கூடுதல் ஹாஷிங் அல்காரிதம்களை (SHA-256 மற்றும் RIPEMD-160 போன்றவை) பயன்படுத்துவதன் மூலம் உருவாக்கப்படுகிறது, மேலும் நிதியை அனுப்பும்போது எழுத்துப்பிழைகளைத் தடுக்க ஒரு சரிபார்ப்புத் தொகையும் (checksum) இதில் அடங்கும். கிரிப்டோகரன்சியைப் பெற மற்றவர்களுடன் நீங்கள் பகிரும் எழுத்துக்களின் சரம் இதுதான்.

• உவமை: பொது சாவி உங்கள் கணக்கு எண் என்றால், முகவரி என்பது பிழை சரிபார்ப்பு அம்சங்களை உள்ளடக்கிய ஒரு குறிப்பிட்ட, வடிவமைக்கப்பட்ட இன்வாய்ஸ் எண் போன்றது.

4. கிரிப்டோகிராஃபிக் இணைப்பு: ஒருவழிப்பாதை

இந்த கூறுகளுக்கு இடையிலான உறவு ஒரு கடுமையான, ஒரு வழி படிநிலை ஆகும்:

தனிப்பட்ட சாவி → பொது சாவி → முகவரி

இந்த வடிவமைப்பு உங்கள் பொது சாவியை நேரடியாக வெளிப்படுத்தாமல் (சில சந்தர்ப்பங்களில்) உங்கள் முகவரியைப் பாதுகாப்பாகப் பகிர முடியும் என்பதையும், உங்கள் தனிப்பட்ட சாவியை ஒருபோதும் வெளிப்படுத்தாமல் இருப்பதையும் உறுதி செய்கிறது.

5. டிஜிட்டல் கையொப்பங்கள்: உரிமையின் ஆதாரம்

நீங்கள் கிரிப்டோகரன்சியை அனுப்ப விரும்பும்போது, ஒரு பரிவர்த்தனை செய்தியை உருவாக்குகிறீர்கள் (எ.கா., "முகவரி A இலிருந்து முகவரி B க்கு 0.5 BTC அனுப்பவும்"). உங்கள் வாலட் மென்பொருள் பின்னர் உங்கள் தனிப்பட்ட சாவியைப் பயன்படுத்தி அந்த குறிப்பிட்ட பரிவர்த்தனைக்கு ஒரு தனித்துவமான டிஜிட்டல் கையொப்பத்தை உருவாக்குகிறது. இந்த கையொப்பம் பரிவர்த்தனையுடன் நெட்வொர்க்கில் பரப்பப்படுகிறது. நெட்வொர்க்கில் உள்ள மைனர்கள் மற்றும் நோடுகள் உங்கள் பொது சாவியைப் பயன்படுத்தி கையொப்பம் செல்லுபடியாகும் என்பதை சரிபார்க்க முடியும், உங்கள் தனிப்பட்ட சாவியை ஒருபோதும் பார்க்காமல் நிதிகளின் சட்டபூர்வமான உரிமையாளரால் பரிவர்த்தனை அங்கீகரிக்கப்பட்டது என்பதை உறுதிப்படுத்துகின்றன.

உங்கள் பைதான் மேம்பாட்டு சூழலை அமைத்தல்

எங்கள் வாலட்டை உருவாக்க, சிக்கலான கிரிப்டோகிராஃபியை கையாளும் சில சிறப்பு பைதான் நூலகங்கள் தேவைப்படும். உங்களிடம் பைதான் 3.6 அல்லது அதற்கு மேற்பட்ட பதிப்பு நிறுவப்பட்டுள்ளதா என்பதை உறுதிப்படுத்தவும். தேவையான தொகுப்புகளை பிப் (pip) பயன்படுத்தி நிறுவலாம்:

            pip install ecdsa pysha3 base58
            

              
                Copy
              
            
          

ஒவ்வொரு நூலகமும் என்ன செய்கிறது என்பதைப் பார்ப்போம்:

• ecdsa: இது எலிப்டிக் கர்வ் டிஜிட்டல் கையொப்ப அல்காரிதம் (ECDSA) செயல்படுத்துவதற்கான ஒரு முக்கியமான நூலகம். பிட்காயின், எத்திரியம் மற்றும் பல கிரிப்டோகரன்சிகளால் பயன்படுத்தப்படும் தரநிலையான SECP256k1 வளைவின் அடிப்படையில் தனிப்பட்ட மற்றும் பொது சாவிகளை உருவாக்க இதை நாங்கள் பயன்படுத்துவோம். இது டிஜிட்டல் கையொப்பங்களை உருவாக்குதல் மற்றும் சரிபார்த்தலையும் கையாளுகிறது.
• pysha3: பைத்தானின் உள்ளமைக்கப்பட்ட hashlib பல ஹாஷிங் அல்காரிதம்களை ஆதரித்தாலும், எத்திரியம் முகவரிகளை உருவாக்க தேவையான Keccak-256 ஐ இது கொண்டிருக்கவில்லை. இந்த நூலகம் அந்த செயல்பாட்டை வழங்குகிறது.
• base58: இந்த நூலகம் Base58Check குறியாக்கத்தை செயல்படுத்துகிறது, இது மனிதர்களுக்கு படிக்கக்கூடிய பிட்காயின் முகவரிகளை உருவாக்கப் பயன்படும் ஒரு வடிவம். எழுத்துப்பிழைகளால் ஏற்படும் பிழைகளைத் தடுக்க இது ஒரு சரிபார்ப்புத் தொகையை (checksum) உள்ளடக்கியது.
• hashlib: இந்த உள்ளமைக்கப்பட்ட பைதான் நூலகம் SHA-256 மற்றும் RIPEMD-160 ஹாஷிங்கிற்குப் பயன்படுத்தப்படும், இவை பிட்காயின் முகவரியை உருவாக்குவதில் அத்தியாவசியமான படிகள்.

படிப்படியான செயல்படுத்தல்: வாலட் தர்க்கத்தை உருவாக்குதல்

இப்போது, குறியீட்டிற்குள் நுழைவோம். எங்கள் வாலட்டின் முக்கிய செயல்பாடுகளை படிப்படியாக உருவாக்குவோம், ஒவ்வொரு அடியையும் விளக்குவோம்.

படி 1: தனிப்பட்ட சாவியை உருவாக்குதல்

ஒரு தனிப்பட்ட சாவி அடிப்படையில் ஒரு 256-பிட் (32-பைட்) எண். மிக முக்கியமான தேவை என்னவென்றால், அது உண்மையான சீரற்ற தன்மையுடன் உருவாக்கப்பட வேண்டும். ஒரு பலவீனமான சீரற்ற எண் ஜெனரேட்டரைப் பயன்படுத்துவது, ஒரு தாக்குதலாளர் யூகிக்கக்கூடிய கணிக்கக்கூடிய சாவிகளுக்கு வழிவகுக்கும்.

பைத்தானின் உள்ளமைக்கப்பட்ட secrets தொகுதி கிரிப்டோகிராஃபிக்கலாக பாதுகாப்பான சீரற்ற எண்களை உருவாக்குவதற்காக வடிவமைக்கப்பட்டுள்ளது, இது எங்கள் தேவைகளுக்கு சரியானதாக அமைகிறது.

            import os
import hashlib
import base58
import ecdsa
from sha3 import keccak_256

def generate_private_key():
    """Generate a secure 32-byte private key."""
    private_key_bytes = os.urandom(32)
    return private_key_bytes
            

              
                Copy
              
            
          

இங்கே, `os.urandom(32)` 32 கிரிப்டோகிராஃபிக்கலாக பாதுகாப்பான சீரற்ற பைட்டுகளை வழங்குகிறது, இது ஒரு 256-பிட் தனிப்பட்ட சாவிக்கு நமக்குத் தேவையான ஒன்று.

படி 2: பொது சாவியைப் பெறுதல்

அடுத்து, `SECP256k1` எலிப்டிக் கர்வ்வைப் பயன்படுத்தி தனிப்பட்ட சாவியிலிருந்து பொது சாவியைப் பெறுகிறோம். `ecdsa` நூலகம் இந்த செயல்முறையை நேரடியானதாக ஆக்குகிறது.

            def private_key_to_public_key(private_key_bytes):
    """Convert a private key to its corresponding public key."""
    # SECP256k1 is the curve used by Bitcoin and Ethereum
    sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    
    # Get the public key in uncompressed format (starts with 0x04)
    vk = sk.verifying_key
    public_key_bytes = vk.to_string("uncompressed")
    return public_key_bytes
            

              
                Copy
              
            
          

ecdsa.SigningKey ஆப்ஜெக்ட் எங்கள் தனிப்பட்ட சாவியைக் குறிக்கிறது. பின்னர், அதற்குரிய verifying_key (பொது சாவி) ஐப் பெற்று, அதை ஒரு "சுருக்கப்படாத" வடிவத்தில் ஏற்றுமதி செய்கிறோம். ஒரு சுருக்கப்படாத பொது சாவி 65 பைட்டுகள் நீளமானது: ஒரு `0x04` முன்னொட்டு, அதைத் தொடர்ந்து எலிப்டிக் கர்வ்வில் ஒரு புள்ளியின் 32-பைட் X ஆள்கூறு மற்றும் 32-பைட் Y ஆள்கூறு.

படி 3: ஒரு பிட்காயின் முகவரியை உருவாக்குதல்

ஒரு பொது சாவியிலிருந்து பிட்காயின் முகவரியை உருவாக்குவது பாதுகாப்பு மற்றும் பிழை சரிபார்ப்பிற்காக வடிவமைக்கப்பட்ட ஒரு பல-படி செயல்முறை ஆகும். நிலையான P2PKH (Pay-to-Public-Key-Hash) முகவரி உருவாக்கும் ஓட்டம் இங்கே:

1. SHA-256 ஹாஷிங்: பொது சாவியை SHA-256 ஐப் பயன்படுத்தி ஹாஷ் செய்யவும்.
2. RIPEMD-160 ஹாஷிங்: முந்தைய படியின் முடிவை RIPEMD-160 ஐப் பயன்படுத்தி ஹாஷ் செய்யவும்.
3. பதிப்பு பைட்டைச் சேர்க்கவும்: RIPEMD-160 ஹாஷிற்கு ஒரு பதிப்பு பைட் முன்னொட்டைச் சேர்க்கவும். பிட்காயின் மெயின்நெட்டிற்கு, இது `0x00`.
4. சரிபார்ப்புத் தொகை கணக்கீடு: நீட்டிக்கப்பட்ட ஹாஷில் SHA-256 ஹாஷிங்கை இருமுறை செய்யவும், மற்றும் இறுதி ஹாஷின் முதல் 4 பைட்டுகளை எடுக்கவும். இது சரிபார்ப்புத் தொகை.
5. சரிபார்ப்புத் தொகையைச் சேர்க்கவும்: 4-பைட் சரிபார்ப்புத் தொகையை பதிப்பு-முன்னொட்டு ஹாஷின் முடிவில் சேர்க்கவும்.
6. Base58Check குறியாக்கம்: முழு பைட் சரத்தையும் Base58Check ஐப் பயன்படுத்தி குறியாக்கம் செய்து இறுதி, மனிதர்களுக்கு படிக்கக்கூடிய முகவரியைப் பெறவும்.

இதை பைத்தானில் செயல்படுத்துவோம்:

            def public_key_to_btc_address(public_key_bytes):
    """Convert a public key to a Bitcoin P2PKH address."""
    # Step 1 & 2: SHA-256 then RIPEMD-160
    sha256_hash = hashlib.sha256(public_key_bytes).digest()
    ripemd160_hash = hashlib.new('ripemd160')
    ripemd160_hash.update(sha256_hash)
    hashed_public_key = ripemd160_hash.digest()

    # Step 3: Add version byte (0x00 for Mainnet)
    version_byte = b'\x00'
    versioned_hash = version_byte + hashed_public_key

    # Step 4 & 5: Create checksum and append
    # Double SHA-256 hash
    checksum_hash_1 = hashlib.sha256(versioned_hash).digest()
    checksum_hash_2 = hashlib.sha256(checksum_hash_1).digest()
    checksum = checksum_hash_2[:4]
    
    binary_address = versioned_hash + checksum

    # Step 6: Base58Check encode
    btc_address = base58.b58encode(binary_address).decode('utf-8')
    return btc_address
            

              
                Copy
              
            
          

படி 4: ஒரு எத்திரியம் முகவரியை உருவாக்குதல்

பிட்காயினுடன் ஒப்பிடும்போது ஒரு எத்திரியம் முகவரியை உருவாக்குவது எளிமையானது. இது பொது சாவியின் Keccak-256 ஹாஷை எடுத்து, முடிவின் கடைசி 20 பைட்டுகளைப் பயன்படுத்துவதை உள்ளடக்கியது.

1. Keccak-256 ஹாஷிங்: பொது சாவியின் Keccak-256 ஹாஷை எடுக்கவும். `0x04` முன்னொட்டு *இல்லாமல்* பொது சாவியைப் பயன்படுத்த வேண்டும் என்பதை கவனிக்கவும்.
2. கடைசி 20 பைட்டுகளை எடுக்கவும்: எத்திரியம் முகவரி இந்த ஹாஷின் கடைசி 20 பைட்டுகள் (40 ஹெக்ஸ் எழுத்துக்கள்) ஆகும்.
3. வடிவமைப்பு: முகவரிக்கு `0x` முன்னொட்டைப் பயன்படுத்துவது பொதுவானது.

pysha3 ஐப் பயன்படுத்தி இதை செயல்படுத்துவோம்:

            def public_key_to_eth_address(public_key_bytes):
    """Convert a public key to an Ethereum address."""
    # Ethereum address generation uses the uncompressed public key without the 0x04 prefix
    uncompressed_pk = public_key_bytes[1:]
    
    # Step 1: Keccak-256 hash
    keccak_hash = keccak_256(uncompressed_pk).digest()
    
    # Step 2: Take the last 20 bytes
    eth_address_bytes = keccak_hash[-20:]
    
    # Step 3: Format with '0x' prefix
    eth_address = '0x' + eth_address_bytes.hex()
    return eth_address
            

              
                Copy
              
            
          

படி 5: ஒரு செய்தியில் கையொப்பமிடுதல்

ஒரு டிஜிட்டல் கையொப்பம் ஒரு தனிப்பட்ட சாவியின் உரிமையாளர் ஒரு செய்தியை (ஒரு பரிவர்த்தனை போன்றது) அங்கீகரித்தார் என்பதை நிரூபிக்கிறது. இந்த செயல்முறை செயல்திறன் மற்றும் பாதுகாப்பிற்காக செய்தியின் ஹாஷில் கையொப்பமிடுவதை உள்ளடக்குகிறது, அசல் செய்தியில் அல்ல.

            def sign_message(private_key_bytes, message):
    """Sign a message with the given private key."""
    # It's standard practice to sign the hash of the message
    message_hash = hashlib.sha256(message.encode('utf-8')).digest()
    
    sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
    signature = sk.sign(message_hash)
    return signature
            

              
                Copy
              
            
          

படி 6: ஒரு கையொப்பத்தை சரிபார்த்தல்

சரிபார்ப்பு என்பது தலைகீழ் செயல்முறை. பொது சாவி, அசல் செய்தி மற்றும் கையொப்பம் உள்ள எவரும் கையொப்பம் உண்மையானது என்பதை உறுதிப்படுத்த முடியும். பிளாக்செயின் நெட்வொர்க் பரிவர்த்தனைகளை இப்படித்தான் சரிபார்க்கிறது.

            def verify_signature(public_key_bytes, signature, message):
    """Verify a signature for a message with the given public key."""
    message_hash = hashlib.sha256(message.encode('utf-8')).digest()
    vk = ecdsa.VerifyingKey.from_string(public_key_bytes, curve=ecdsa.SECP256k1, hashfunc=hashlib.sha256)
    
    try:
        # The verify method will return True if valid, or raise an exception
        return vk.verify(signature, message_hash)
    except ecdsa.BadSignatureError:
        return False
            

              
                Copy
              
            
          

வாலட்டை ஒருங்கிணைத்தல்: ஒரு எளிய கட்டளை-வரி இடைமுகம் (CLI)

இப்போது எங்களிடம் அனைத்து முக்கிய செயல்பாடுகளும் உள்ளன, அவற்றை ஒரு எளிய, பயன்படுத்தக்கூடிய கட்டளை-வரி கருவியாக மாற்றுவோம். தர்க்கத்தை இணைக்க ஒரு `Wallet` வகுப்பை உருவாக்கி, பயனர் கட்டளைகளைக் கையாள பைத்தானின் `argparse` தொகுதியைப் பயன்படுத்துவோம்.

எங்கள் அனைத்து செயல்பாடுகளையும் ஒரு ஒருங்கிணைந்த பயன்பாட்டில் ஒருங்கிணைக்கும் ஒரு முழுமையான ஸ்கிரிப்ட் இங்கே.

            #!/usr/bin/env python3

import os
import hashlib
import base58
import ecdsa
import argparse
from sha3 import keccak_256

class Wallet:
    """Represents a cryptocurrency wallet with key management and address generation."""
    def __init__(self, private_key_hex=None):
        if private_key_hex:
            self.private_key = bytes.fromhex(private_key_hex)
        else:
            self.private_key = self._generate_private_key()
        
        self.public_key = self._private_to_public_key(self.private_key)
        self.btc_address = self._public_to_btc_address(self.public_key)
        self.eth_address = self._public_to_eth_address(self.public_key)

    def _generate_private_key(self):
        return os.urandom(32)

    def _private_to_public_key(self, private_key):
        sk = ecdsa.SigningKey.from_string(private_key, curve=ecdsa.SECP256k1)
        return sk.verifying_key.to_string("uncompressed")

    def _public_to_btc_address(self, public_key):
        sha256_hash = hashlib.sha256(public_key).digest()
        ripemd160 = hashlib.new('ripemd160')
        ripemd160.update(sha256_hash)
        hashed_pk = ripemd160.digest()
        
        versioned_hash = b'\x00' + hashed_pk
        checksum = hashlib.sha256(hashlib.sha256(versioned_hash).digest()).digest()[:4]
        binary_address = versioned_hash + checksum
        return base58.b58encode(binary_address).decode('utf-8')

    def _public_to_eth_address(self, public_key):
        uncompressed_pk = public_key[1:]
        keccak_hash = keccak_256(uncompressed_pk).digest()
        return '0x' + keccak_hash[-20:].hex()

    def display_details(self):
        print(f"Private Key (hex): {self.private_key.hex()}")
        print(f"Public Key (hex):  {self.public_key.hex()}")
        print(f"Bitcoin Address:   {self.btc_address}")
        print(f"Ethereum Address:  {self.eth_address}")

def main():
    parser = argparse.ArgumentParser(description="A simple command-line cryptocurrency wallet.")
    parser.add_argument("command", choices=["create", "details"], help="The command to execute.")
    parser.add_argument("--privatekey", help="An existing private key in hex format to get details from.")

    args = parser.parse_args()

    if args.command == "create":
        wallet = Wallet()
        print("--- New Wallet Created ---")
        wallet.display_details()
        print("\n*** IMPORTANT ***")
        print("Save your private key in a secure location. It is the only way to access your funds.")

    elif args.command == "details":
        if not args.privatekey:
            print("Error: The 'details' command requires a private key using the --privatekey flag.")
            return
        try:
            wallet = Wallet(private_key_hex=args.privatekey)
            print("--- Wallet Details ---")
            wallet.display_details()
        except Exception as e:
            print(f"Error loading wallet from private key: {e}")

if __name__ == "__main__":
    main()
            

              
                Copy
              
            
          

இந்த CLI கருவியை எவ்வாறு பயன்படுத்துவது:

1. மேலே உள்ள குறியீட்டை ஒரு பைதான் கோப்பாகச் சேமிக்கவும் (எ.கா., `cli_wallet.py`).
2. உங்கள் டெர்மினல் அல்லது கமாண்ட் ப்ராம்ப்ட்டைத் திறக்கவும்.
3. ஒரு புதிய வாலட்டை உருவாக்க: `python cli_wallet.py create`
4. ஏற்கனவே உள்ள தனிப்பட்ட சாவியிலிருந்து விவரங்களைக் காண: `python cli_wallet.py details --privatekey YOUR_PRIVATE_KEY_IN_HEX`

பாதுகாப்பு சிறந்த நடைமுறைகள் மற்றும் முக்கியமான பரிசீலனைகள்

நாங்கள் ஒரு அடிப்படை வாலட்டை வெற்றிகரமாக உருவாக்கியுள்ளோம், ஆனால் உற்பத்திக்கு தயாரான பயன்பாட்டிற்கு பாதுகாப்பில் மிக ஆழமான கவனம் தேவை. கருத்தில் கொள்ள வேண்டிய சில முக்கியமான அம்சங்கள் இங்கே.

1. தனிப்பட்ட சாவிகளை ஒருபோதும் அசல் வடிவத்தில் சேமிக்க வேண்டாம்

எங்கள் ஸ்கிரிப்ட் தனிப்பட்ட சாவியை கன்சோலில் அச்சிடுகிறது, இது மிகவும் பாதுகாப்பற்றது. ஒரு உண்மையான பயன்பாட்டில், தனிப்பட்ட சாவிகள் வலுவான கடவுச்சொல்லைப் பயன்படுத்தி, சேமிப்பில் குறியாக்கம் செய்யப்பட வேண்டும். கையொப்பமிடுவதற்கு தேவைப்படும்போது மட்டுமே அவை நினைவகத்தில் மறைகுறியாக்கப்பட வேண்டும். தொழில்முறை தீர்வுகள் பெரும்பாலும் விசைகளைப் பாதுகாக்க சாதனங்களில் வன்பொருள் பாதுகாப்பு தொகுதிகள் (HSMகள்) அல்லது பாதுகாப்பான என்கிளேவ்களைப் பயன்படுத்துகின்றன.

2. என்ட்ரோபியின் முக்கியத்துவம்

உங்கள் வாலட்டின் பாதுகாப்பு தனிப்பட்ட சாவியை உருவாக்கப் பயன்படுத்தப்படும் சீரற்ற தன்மையுடன் (என்ட்ரோபி) தொடங்குகிறது. `os.urandom` பெரும்பாலான நவீன இயக்க முறைமைகளில் ஒரு நல்ல ஆதாரம், ஆனால் அதிக மதிப்புள்ள பயன்பாடுகளுக்கு, டெவலப்பர்கள் கணிக்க முடியாத தன்மையை உறுதிப்படுத்த பல ஆதாரங்களில் இருந்து என்ட்ரோபியை சேகரிக்கின்றனர்.

3. நினைவூட்டல் சொற்றொடர்கள் (Mnemonic Phrases) - தொழில்துறை தரநிலை

நீண்ட ஹெக்ஸாடெசிமல் தனிப்பட்ட சாவிகளை கைமுறையாக காப்புப் பிரதி எடுப்பது கடினமானது மற்றும் பிழை ஏற்படக்கூடியது. தொழில்துறை இதை படிநிலை நிர்ணய (HD) வாலட்கள் (BIP-32 இல் வரையறுக்கப்பட்டது) மற்றும் நினைவூட்டல் சொற்றொடர்கள் (BIP-39) மூலம் தீர்த்தது. ஒரு நினைவூட்டல் சொற்றொடர் என்பது 12-24 பொதுவான சொற்களின் ஒரு வரிசை ஆகும், இது உங்கள் மாஸ்டர் தனிப்பட்ட சாவி மற்றும் அதைத் தொடர்ந்து வரும் அனைத்து சாவிகளையும் உறுதியாக மீண்டும் உருவாக்க பயன்படுகிறது. இது வாலட் காப்புப்பிரதி மற்றும் மீட்பை மிகவும் பயனர் நட்புள்ளதாக்குகிறது.

4. இது ஒரு கல்வி கருவி, உற்பத்தி வாலட் அல்ல

இந்தச் செயல்படுத்துதல் ஒரு எளிமைப்படுத்தப்பட்ட மாதிரி என்பதை மீண்டும் வலியுறுத்துவது மிக முக்கியம். ஒரு நிஜ உலக வாலட் பல முகவரிகளை நிர்வகிக்க வேண்டும், இருப்புகளைப் பெறவும் பரிவர்த்தனைகளை உருவாக்கவும் பிளாக்செயின் நோடுகளுடன் தொடர்பு கொள்ள வேண்டும், கட்டணங்களைக் கணக்கிட வேண்டும், மற்றும் கையொப்பமிடப்பட்ட பரிவர்த்தனைகளை நெட்வொர்க்கில் ஒளிபரப்ப வேண்டும். இதற்கு ஒரு பாதுகாப்பான பயனர் இடைமுகம் மற்றும் வலுவான பிழை கையாளுதலும் தேவை.

5. நெட்வொர்க் தொடர்பு

எங்கள் வாலட் சாவிகளை உருவாக்கலாம் மற்றும் செய்திகளில் கையொப்பமிடலாம், ஆனால் இது ஒரு பிளாக்செயின் நெட்வொர்க்குடன் தொடர்பு கொள்ள முடியாது. ஒரு முழுமையான பயன்பாட்டை உருவாக்க, RPC (Remote Procedure Call) வழியாக பிளாக்செயின் நோடுகளுடன் இணையக்கூடிய நூலகங்களை ஒருங்கிணைக்க வேண்டும். எத்திரியத்திற்கு, `web3.py` ஒரு நிலையான நூலகம். பிட்காயினுக்கு, `python-bitcoinlib` போன்ற நூலகங்களைப் பயன்படுத்தலாம்.

முடிவுரை மற்றும் அடுத்த படிகள்

வாழ்த்துக்கள்! நீங்கள் பைதான் பயன்படுத்தி ஒரு கிரிப்டோகரன்சி வாலட்டின் கிரிப்டோகிராஃபிக் மையத்தை வெற்றிகரமாக உருவாக்கியுள்ளீர்கள். பொது/தனிப்பட்ட சாவி கிரிப்டோகிராஃபியின் அடிப்படை கோட்பாட்டிலிருந்து, பிட்காயின் மற்றும் எத்திரியம் நெட்வொர்க்குகள் இரண்டிற்கும் செல்லுபடியாகும் முகவரிகளை உருவாக்கும் ஒரு நடைமுறை செயல்படுத்தலுக்கு நாம் பயணித்துள்ளோம்.

இந்த திட்டம் பிளாக்செயின் தொழில்நுட்பத்தை ஆழமாக ஆராய்வதற்கு ஒரு வலுவான அடித்தளத்தை வழங்குகிறது. ஒரு வாலட் என்பது, அதன் மையத்தில், நிரூபிக்கப்பட்ட கிரிப்டோகிராஃபிக் கோட்பாடுகளின் அடிப்படையில் கட்டப்பட்ட ஒரு அதிநவீன சாவி மேலாண்மை அமைப்பு என்பதை நீங்கள் நேரடியாகக் கண்டிருக்கிறீர்கள்.

இங்கிருந்து நீங்கள் எங்கு செல்கிறீர்கள்? உங்கள் அடுத்த படிகளாக இந்த சவால்களைக் கருத்தில் கொள்ளுங்கள்:

• HD வாலட்களை செயல்படுத்துங்கள்: ஒரு ஒற்றை நினைவூட்டல் விதை சொற்றொடரிலிருந்து மில்லியன் கணக்கான முகவரிகளை நிர்வகிக்கக்கூடிய ஒரு வாலட்டை உருவாக்க BIP-32, BIP-39 மற்றும் BIP-44 தரநிலைகளை ஆராயுங்கள்.
• நெட்வொர்க்குடன் இணைக்கவும்: ஒரு எத்திரியம் நோடுடன் (Infura அல்லது Alchemy போன்றவை) இணைக்க `web3.py` ஐப் பயன்படுத்தவும், ஒரு முகவரி இருப்பைச் சரிபார்த்து, ஒரு அசல் பரிவர்த்தனையை உருவாக்கவும்.
• ஒரு பயனர் இடைமுகத்தை உருவாக்குங்கள்: உங்கள் வாலட்டை மேலும் பயனர் நட்புள்ளதாக்க Tkinter போன்ற ஒரு கட்டமைப்பைப் பயன்படுத்தி ஒரு எளிய வரைகலை பயனர் இடைமுகத்தை (GUI) அல்லது Flask/Django ஐப் பயன்படுத்தி ஒரு வலை இடைமுகத்தை உருவாக்கவும்.
• பிற பிளாக்செயின்களை ஆராயுங்கள்: மற்ற பிளாக்செயின் தளங்கள் தங்கள் முகவரிகளை எவ்வாறு உருவாக்குகின்றன என்பதை ஆராய்ந்து, அவற்றை ஆதரிக்க உங்கள் குறியீட்டை மாற்றியமைக்கவும்.

பிளாக்செயின் உலகம் திறந்த மூல ஒத்துழைப்பு மற்றும் அறிவிற்கான தாகத்தின் அடிப்படையில் கட்டப்பட்டது. இது போன்ற கருவிகளை உருவாக்குவதன் மூலம், நீங்கள் குறியீடு எழுதுவதைக் கற்றுக்கொள்வது மட்டுமல்ல—நீங்கள் ஒரு புதிய டிஜிட்டல் பொருளாதாரத்தின் மொழியைக் கற்றுக்கொள்கிறீர்கள். தொடர்ந்து பரிசோதித்து, தொடர்ந்து உருவாக்கி, பரவலாக்கப்பட்ட தொழில்நுட்பத்தின் பரந்த ஆற்றலை தொடர்ந்து ஆராயுங்கள்.