以太坊源码之『账户管理钱包分析』

如何实现通过geth生成以太坊地址？

personal.newAccount(password)

// 创建一个新的账号
func accountCreate(ctx *cli.Context) error {
	// 获取geth配置
	cfg := gethConfig{Node: defaultNodeConfig()}
	// 加载配置文件
	if file := ctx.GlobalString(configFileFlag.Name); file != "" {
		if err := loadConfig(file, &cfg); err != nil {
			utils.Fatalf("%v", err)
		}
	}
	// 设置节点相关协议配置
	utils.SetNodeConfig(ctx, &cfg.Node)
	// 获取账号配置
	scryptN, scryptP, keydir, err := cfg.Node.AccountConfig()

	if err != nil {
		utils.Fatalf("Failed to read configuration: %v", err)
	}
	// 解析用户密码
	password := getPassPhrase("Your new account is locked with a password. Please give a password. Do not forget this password.", true, 0, utils.MakePasswordList(ctx))
	// 通过密码获取一个新的地址，存储到keystore目录
	address, err := keystore.StoreKey(keydir, password, scryptN, scryptP)

	if err != nil {
		utils.Fatalf("Failed to create account: %v", err)
	}
	fmt.Printf("Address: {%x}\n", address)
	return nil
}

accounts源码分析：

在accounts包中，主要实现了以太坊客户端的钱包管理和账户管理，提供了两种钱包，分别是keystore,usb。同时以太坊合约代码的ABI也在accounts中实现。

key.go中

// 生成新的key结构
func newKey(rand io.Reader) (*Key, error) {
	// 通过ecdsa生成一对公私钥对
	privateKeyECDSA, err := ecdsa.GenerateKey(crypto.S256(), rand)
	if err != nil {
		return nil, err
	}
	// 通过ecdsa公钥生成key结构
	return newKeyFromECDSA(privateKeyECDSA), nil
}
// 生成地址，存储
func storeNewKey(ks keyStore, rand io.Reader, auth string) (*Key, accounts.Account, error) {
	// 通过给定的随机数生成新的key结构
	key, err := newKey(rand)
	if err != nil {
		return nil, accounts.Account{}, err
	}
	// 封装生成address
	a := accounts.Account{Address: key.Address, URL: accounts.URL{Scheme: KeyStoreScheme, Path: ks.JoinPath(keyFileName(key.Address))}}
	// 存储私钥
	if err := ks.StoreKey(a.URL.Path, key, auth); err != nil {
		zeroKey(key.PrivateKey)
		return nil, a, err
	}
	return key, a, err
}

keystore_passphrase.go

accounts.go

package accounts

import (
	"math/big"

	ethereum "github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/event"
)

// 以太坊地址类型结构
type Account struct {
	// 20字节的数据
	Address common.Address `json:"address"` // Ethereum account address derived from the key
	URL     URL            `json:"url"`     // Optional resource locator within a backend
}

// 钱包接口
type Wallet interface {
	// 获取该钱包可以访问的规范路径
	URL() URL
	// 钱包状态
	Status() (string, error)
	// 初始化对钱包实例的访问
	Open(passphrase string) error
	// 释放open方法占用的资源
	Close() error
	// 账号列表
	Accounts() []Account
	// 查询指定账户是否属于该钱包
	Contains(account Account) bool
	// 专门给确定性钱包使用的
	Derive(path DerivationPath, pin bool) (Account, error)
	// 设置一个账户导出路径
	SelfDerive(base DerivationPath, chain ethereum.ChainStateReader)
	// 请求钱包为传入的哈希进行签名
	SignHash(account Account, hash []byte) ([]byte, error)
	// 请求钱包为传入的交易进行签名
	SignTx(account Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
	// 请求钱包使用指定 的passphrase为传入的哈希进行签名
	SignHashWithPassphrase(account Account, passphrase string, hash []byte) ([]byte, error)
	// 请求钱包使用指定 的passphrase为传入的交易进行签名
	SignTxWithPassphrase(account Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)
}

// 钱包的后端实现(服务)，主要实现keystore钱包以及USB硬件钱包
type Backend interface {
	// 获取钱包列表
	Wallets() []Wallet
	// 订阅钱包相关事件
	Subscribe(sink chan<- WalletEvent) event.Subscription
}
// 钱包事件的类型
type WalletEventType int

const (
	// 在通过USB或者密码文件检测到新钱包的时候 ，会触发该事件
	WalletArrived WalletEventType = iota
	// 开户钱包所触发的事件
	WalletOpened
	WalletDropped
)
// 在检测到钱包账户发生改变时所触发的事件
type WalletEvent struct {
	Wallet Wallet          
	Kind   WalletEventType 
}

---

以太坊钱包管理器manager分析：

manager.go：

package accounts

import (
	"reflect"
	"sort"
	"sync"

	"github.com/ethereum/go-ethereum/event"
)
// 账户管理工具，可以和所有的backends进行通信来签名交易
type Manager struct {
	// 已注册的后台服务
	backends map[reflect.Type][]Backend
	// 钱包管理相关事件
	updaters []event.Subscription
	updates  chan WalletEvent
	// 已经注册过的钱包缓存
	wallets  []Wallet

	feed event.Feed

	quit chan chan error
	lock sync.RWMutex
}
// 新建管理器对象
func NewManager(backends ...Backend) *Manager {
	var wallets []Wallet
	for _, backend := range backends {
		// 调用所有backend的wallet方法，合并成完整的钱包列表
		wallets = merge(wallets, backend.Wallets()...)
	}
	updates := make(chan WalletEvent, 4*len(backends))

	subs := make([]event.Subscription, len(backends))
	for i, backend := range backends {
		// 注册update channel到后端服务中
		subs[i] = backend.Subscribe(updates)
	}
	// 封装
	am := &Manager{
		backends: make(map[reflect.Type][]Backend),
		updaters: subs,
		updates:  updates,
		wallets:  wallets,
		quit:     make(chan chan error),
	}
	for _, backend := range backends {
		kind := reflect.TypeOf(backend)
		am.backends[kind] = append(am.backends[kind], backend)
	}

	// 另起协程，监听钱包事件
	go am.update()

	return am
}
// 关闭账号管理器
func (am *Manager) Close() error {
	errc := make(chan error)
	am.quit <- errc
	return <-errc
}
// 钱包事件
func (am *Manager) update() {
	defer func() {
		am.lock.Lock()
		for _, sub := range am.updaters {
			sub.Unsubscribe()
		}
		am.updaters = nil
		am.lock.Unlock()
	}()
	// 循环监听钱包相关事件
	for {
		select {
		case event := <-am.updates:
			am.lock.Lock()
			switch event.Kind {
			// 判断事件类型
			case WalletArrived:
				am.wallets = merge(am.wallets, event.Wallet)
			case WalletDropped:
				am.wallets = drop(am.wallets, event.Wallet)
			}
			am.lock.Unlock()

			am.feed.Send(event)
		// 接收退出
		case errc := <-am.quit:
			errc <- nil
			return
		}
	}
}

// 返回指定的服务列表
func (am *Manager) Backends(kind reflect.Type) []Backend {
	return am.backends[kind]
}

// 返回该账号管理器下的所有签名账户
func (am *Manager) Wallets() []Wallet {
	am.lock.RLock()
	defer am.lock.RUnlock()

	cpy := make([]Wallet, len(am.wallets))
	copy(cpy, am.wallets)
	return cpy
}

// 通过URL查找指定的钱包
func (am *Manager) Wallet(url string) (Wallet, error) {
	am.lock.RLock()
	defer am.lock.RUnlock()

	parsed, err := parseURL(url)
	if err != nil {
		return nil, err
	}
	for _, wallet := range am.Wallets() {
		if wallet.URL() == parsed {
			return wallet, nil
		}
	}
	return nil, ErrUnknownWallet
}
// 通过指定的ACCOUNT查找钱包
func (am *Manager) Find(account Account) (Wallet, error) {
	am.lock.RLock()
	defer am.lock.RUnlock()

	for _, wallet := range am.wallets {
		if wallet.Contains(account) {
			return wallet, nil
		}
	}
	return nil, ErrUnknownAccount
}
// 订阅事件
func (am *Manager) Subscribe(sink chan<- WalletEvent) event.Subscription {
	return am.feed.Subscribe(sink)
}
// 在指定的位置插入钱包，保证原来列表的顺序
func merge(slice []Wallet, wallets ...Wallet) []Wallet {
	for _, wallet := range wallets {
		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
		if n == len(slice) {
			slice = append(slice, wallet)
			continue
		}
		slice = append(slice[:n], append([]Wallet{wallet}, slice[n:]...)...)
	}
	return slice
}
// 删除钱包列表中指定的钱包
func drop(slice []Wallet, wallets ...Wallet) []Wallet {
	for _, wallet := range wallets {
		n := sort.Search(len(slice), func(i int) bool { return slice[i].URL().Cmp(wallet.URL()) >= 0 })
		if n == len(slice) {
			continue
		}
		slice = append(slice[:n], slice[n+1:]...)
	}
	return slice
}

钱包列表获取与事件流程：

通过架构图，可以看到一个wallet中可以包含多个account,每个account中包含一个address结构(address, URL)

accounts中核心接口：

• Backend接口：钱包后端，目前实现了keystore钱包和USB硬件钱包
• Wallet接口：单个钱包，包含了一些打开 ，关闭，签名相关的接口函数

type KeyStore struct {
	// keyStore接口，用于访问账户关联的私钥
	storage  keyStore                     // Storage backend, might be cleartext or encrypted
	cache    *accountCache                // In-memory account cache over the filesystem storage
	changes  chan struct{}                // Channel receiving change notifications from the cache
	unlocked map[common.Address]*unlocked // Currently unlocked account (decrypted private keys)

	// 所有钱包的集合，
	wallets     []accounts.Wallet       // Wallet wrappers around the individual key files
	updateFeed  event.Feed              // Event feed to notify wallet additions/removals
	updateScope event.SubscriptionScope // Subscription scope tracking current live listeners
	updating    bool                    // Whether the event notification loop is running

	mu sync.RWMutex
}

type unlocked struct {
	*Key
	abort chan struct{}
}
// 概念指定的目录创建一个keystore
func NewKeyStore(keydir string, scryptN, scryptP int) *KeyStore {
	keydir, _ = filepath.Abs(keydir)
	ks := &KeyStore{storage: &keyStorePassphrase{keydir, scryptN, scryptP}}
	ks.init(keydir)
	return ks
}
func NewPlaintextKeyStore(keydir string) *KeyStore {
	keydir, _ = filepath.Abs(keydir)
	ks := &KeyStore{storage: &keyStorePlain{keydir}}
	ks.init(keydir)
	return ks
}

func (ks *KeyStore) init(keydir string) {
	ks.mu.Lock()
	defer ks.mu.Unlock()
	ks.unlocked = make(map[common.Address]*unlocked)
	// 创建一个accountCache实例
	ks.cache, ks.changes = newAccountCache(keydir)
	runtime.SetFinalizer(ks, func(m *KeyStore) {
		m.cache.close()
	})
	// 获取当前的账号列表
	accs := ks.cache.accounts()
	ks.wallets = make([]accounts.Wallet, len(accs))
	for i := 0; i < len(accs); i++ {
		// 将keyStore填充到钱包中去
		ks.wallets[i] = &keystoreWallet{account: accs[i], keystore: ks}
	}
}
// 通过keystore获取wallet列表
func (ks *KeyStore) Wallets() []accounts.Wallet {
	ks.refreshWallets()

	ks.mu.RLock()
	defer ks.mu.RUnlock()

	cpy := make([]accounts.Wallet, len(ks.wallets))
	copy(cpy, ks.wallets)
	return cpy
}

config.go

// 创建一个账号管理器
func makeAccountManager(conf *Config) (*accounts.Manager, string, error) {
	// 获取配送配置以及私钥存储的目录
	scryptN, scryptP, keydir, err := conf.AccountConfig()
	var ephemeral string
	if keydir == "" {
		keydir, err = ioutil.TempDir("", "go-ethereum-keystore")
		ephemeral = keydir
	}

	if err != nil {
		return nil, "", err
	}
	// 以700权限创建keystore目录，默认为datadir/keystore
	if err := os.MkdirAll(keydir, 0700); err != nil {
		return nil, "", err
	}
	// 初始化backend列表,创建keyStore实例
	backends := []accounts.Backend{
		keystore.NewKeyStore(keydir, scryptN, scryptP),
	}
	if !conf.NoUSB {
		if ledgerhub, err := usbwallet.NewLedgerHub(); err != nil {
			log.Warn(fmt.Sprintf("Failed to start Ledger hub, disabling: %v", err))
		} else {
			backends = append(backends, ledgerhub)
		}
		if trezorhub, err := usbwallet.NewTrezorHub(); err != nil {
			log.Warn(fmt.Sprintf("Failed to start Trezor hub, disabling: %v", err))
		} else {
			backends = append(backends, trezorhub)
		}
	}
	// 在账户的列表初始化完成之后，通过NewManager函数创建一个账号管理器
	return accounts.NewManager(backends...), ephemeral, nil
}

钱包事件：

• Manager中：updates字段，channel类型，主要用于接收钱包相关的事件。Manage需要调用backend的subscribe函数注册channel
• Keystore:后端的事件，把注册请求转发给feed实例
• Feed把channel记录下来
• Manager可以能过该接口取消订阅