Implementation code for creating wallets and traversing wallets in GO language

Basic knowledge

The public key encryption algorithm uses paired keys: public keys and private keys. The public key can be publicly disclosed, but the private key cannot be publicly disclosed. A Bitcoin wallet is actually a key pair. When you install a wallet application, or use a Bitcoin client to generate a new address, it will generate a key pair for you.

Code implementation

func (cli *CLI) createWallet(nodeID string) {     //The main function to create the wallet    wallets, _ := NewWallets(nodeID)   
    address := ()
    (nodeID)

    ("Your new address: %s\n", address)
}

We slowly analyze this program. The NewWallets() function is as follows. Here we first define a wallet collection. We use the wallets structure to store multiple wallets, save them to files or load them from files. Each wallet saves a bunch of public and private keys. After creating an empty wallet collection, the previous wallet collection file begins to be loaded

func NewWallets(nodeID string) (*Wallets, error) {
    wallets := Wallets{}
     = make(map[string]*Wallet)
    err := (nodeID)
    return &amp;wallets, err
}

type Wallets struct {
    Wallets map[string]*Wallet
}
type Wallet struct {
    PrivateKey 
    PublicKey  []byte
}
func (ws *Wallets) LoadFromFile(nodeID string) error {
    walletFile := (walletFile, nodeID)    
    if _, err := (walletFile); (err) {   //Judge whether the file exists        return err
    }

    fileContent, err := (walletFile)
    // ReadFile Reads all data in the file, returning the read data and errors encountered.    //If the read is successful, err returns nil, not EOFfunc ReadFile(filename string) ([]byte, error)
    if err != nil {
        (err)
    }

    var wallets Wallets
    (elliptic.P256())
    //gob is a data structure serialization encoding/decoding tool provided by the Golang package.    decoder := ((fileContent))
    err = (&amp;wallets)//This should be a decoding process    if err != nil {
        (err)
    }
     = 
    return nil
}

Let's take a look at the() method. The NewWallet() function is as follows. The NewWallet() function creates a wallet. We can print out the corresponding address of the corresponding wallet according to the public key, and then store the wallet in the wallet collection structure.

unc (ws *Wallets) CreateWallet() string {
    wallet := NewWallet()
    address := ("%s", ())
    [address] = wallet  //Storage into the wallet collection    return address
}
func NewWallet() *Wallet {
    private, public := newKeyPair()   //Get the public and private key    wallet := Wallet{private, public}  //Storage to wallet structure    return &amp;wallet
}
func newKeyPair() (, []byte) {
    curve := elliptic.P256()
    private, err := (curve, )
    if err != nil {
        (err)
    }
    pubKey := append((), ()...)
    return *private, pubKey
}

//Get the address from the public key. For the specific method, please see my blog using ["Go language to implement Bitcoin address verification"](/m0_37719047/article/details/81945896)func (w Wallet) GetAddress() []byte {     
    pubKeyHash := HashPubKey()  
    versionedPayload := append([]byte{version}, pubKeyHash...)
    checksum := checksum(versionedPayload)
    fullPayload := append(versionedPayload, checksum...)
    address := Base58Encode(fullPayload)
    return address
}

Finally, update the created wallet to the file that stores the wallet collection

func (ws Wallets) SaveToFile(nodeID string) {
    var content      //Open a memory space    walletFile := (walletFile, nodeID)
    (elliptic.P256())
    encoder := (&amp;content)    //Serialize the structure    err := (ws)
    if err != nil {
        (err)
    }
    err = (walletFile, (), 0644)    //Write the serialized data into the file    if err != nil {
        (err)
    }
}

If we need to print the addresses corresponding to all wallets in the wallet collection, we can use the following function to traverse.

func (cli *CLI) listAddresses(nodeID string) {
    wallets, err := NewWallets(nodeID)   //Load existing wallet collection    if err != nil {
        (err)
    }
    addresses := ()
    for _, address := range addresses {
        (address)
    }
}
func (ws *Wallets) GetAddresses() []string {
    var addresses []string
    for address := range  {
        addresses = append(addresses, address)
    }
    return addresses
}

Through the above code, we have completed the wallet and realized the functions of creating wallets and traversing wallets

refer to

The above is the detailed content of the implementation code for creating a wallet and traversing a wallet in GO language. For more information about traversing a wallet in GO language, please pay attention to my other related articles!