diff --git a/accounts/usbwallet/ledger.go b/accounts/usbwallet/ledger.go
new file mode 100644
index 0000000000000000000000000000000000000000..55b313df9d8b2aae7cab312669bf309c297044b1
--- /dev/null
+++ b/accounts/usbwallet/ledger.go
@@ -0,0 +1,648 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// This file contains the implementation for interacting with the Ledger hardware
+// wallets. The wire protocol spec can be found in the Ledger Blue GitHub repo:
+// https://raw.githubusercontent.com/LedgerHQ/blue-app-eth/master/doc/ethapp.asc
+
+package usbwallet
+
+import (
+ "encoding/binary"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "io"
+ "math/big"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "github.com/ethereum/go-ethereum/accounts"
+ "github.com/ethereum/go-ethereum/common"
+ "github.com/ethereum/go-ethereum/core/types"
+ "github.com/ethereum/go-ethereum/logger"
+ "github.com/ethereum/go-ethereum/logger/glog"
+ "github.com/ethereum/go-ethereum/rlp"
+ "github.com/karalabe/gousb/usb"
+)
+
+// ledgerDeviceIDs are the known device IDs that Ledger wallets use.
+var ledgerDeviceIDs = []deviceID{
+ {Vendor: 0x2c97, Product: 0x0000}, // Ledger Blue
+ {Vendor: 0x2c97, Product: 0x0001}, // Ledger Nano S
+}
+
+// ledgerDerivationPath is the key derivation parameters used by the wallet.
+var ledgerDerivationPath = [4]uint32{0x80000000 + 44, 0x80000000 + 60, 0x80000000 + 0, 0}
+
+// ledgerOpcode is an enumeration encoding the supported Ledger opcodes.
+type ledgerOpcode byte
+
+// ledgerParam1 is an enumeration encoding the supported Ledger parameters for
+// specific opcodes. The same parameter values may be reused between opcodes.
+type ledgerParam1 byte
+
+// ledgerParam2 is an enumeration encoding the supported Ledger parameters for
+// specific opcodes. The same parameter values may be reused between opcodes.
+type ledgerParam2 byte
+
+const (
+ ledgerOpRetrieveAddress ledgerOpcode = 0x02 // Returns the public key and Ethereum address for a given BIP 32 path
+ ledgerOpSignTransaction ledgerOpcode = 0x04 // Signs an Ethereum transaction after having the user validate the parameters
+ ledgerOpGetConfiguration ledgerOpcode = 0x06 // Returns specific wallet application configuration
+
+ ledgerP1DirectlyFetchAddress ledgerParam1 = 0x00 // Return address directly from the wallet
+ ledgerP1ConfirmFetchAddress ledgerParam1 = 0x01 // Require a user confirmation before returning the address
+ ledgerP1InitTransactionData ledgerParam1 = 0x00 // First transaction data block for signing
+ ledgerP1ContTransactionData ledgerParam1 = 0x80 // Subsequent transaction data block for signing
+ ledgerP2DiscardAddressChainCode ledgerParam2 = 0x00 // Do not return the chain code along with the address
+ ledgerP2ReturnAddressChainCode ledgerParam2 = 0x01 // Require a user confirmation before returning the address
+)
+
+// ledgerWallet represents a live USB Ledger hardware wallet.
+type ledgerWallet struct {
+ device *usb.Device // USB device advertising itself as a Ledger wallet
+ input usb.Endpoint // Input endpoint to send data to this device
+ output usb.Endpoint // Output endpoint to receive data from this device
+
+ address common.Address // Current address of the wallet (may be zero if Ethereum app offline)
+ url string // Textual URL uniquely identifying this wallet
+ version [3]byte // Current version of the Ledger Ethereum app (zero if app is offline)
+}
+
+// LedgerHub is a USB hardware wallet interface that can find and handle Ledger
+// wallets.
+type LedgerHub struct {
+ ctx *usb.Context // Context interfacing with a libusb instance
+
+ wallets map[uint16]*ledgerWallet // Apparent Ledger wallets (some may be inactive)
+ accounts []accounts.Account // List of active Ledger accounts
+ index map[common.Address]uint16 // Set of addresses with active wallets
+
+ quit chan chan error
+ lock sync.RWMutex
+}
+
+// NewLedgerHub creates a new hardware wallet manager for Ledger devices.
+func NewLedgerHub() (*LedgerHub, error) {
+ // Initialize the USB library to access Ledgers through
+ ctx, err := usb.NewContext()
+ if err != nil {
+ return nil, err
+ }
+ // Create the USB hub, start and return it
+ hub := &LedgerHub{
+ ctx: ctx,
+ wallets: make(map[uint16]*ledgerWallet),
+ index: make(map[common.Address]uint16),
+ quit: make(chan chan error),
+ }
+ go hub.watch()
+ return hub, nil
+}
+
+// Accounts retrieves the live of accounts currently known by the Ledger hub.
+func (hub *LedgerHub) Accounts() []accounts.Account {
+ hub.lock.RLock()
+ defer hub.lock.RUnlock()
+
+ cpy := make([]accounts.Account, len(hub.accounts))
+ copy(cpy, hub.accounts)
+ return cpy
+}
+
+// HasAddress reports whether an account with the given address is present.
+func (hub *LedgerHub) HasAddress(addr common.Address) bool {
+ hub.lock.RLock()
+ defer hub.lock.RUnlock()
+
+ _, known := hub.index[addr]
+ return known
+}
+
+// SignHash is not supported for Ledger wallets, so this method will always
+// return an error.
+func (hub *LedgerHub) SignHash(acc accounts.Account, hash []byte) ([]byte, error) {
+ return nil, accounts.ErrNotSupported
+}
+
+// SignTx sends the transaction over to the Ledger wallet to request a confirmation
+// from the user. It returns either the signed transaction or a failure if the user
+// denied the transaction.
+//
+// Note, if the version of the Ethereum application running on the Ledger wallet is
+// too old to sign EIP-155 transactions, but such is requested nonetheless, an error
+// will be returned opposed to silently signing in Homestead mode.
+func (hub *LedgerHub) SignTx(acc accounts.Account, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
+ hub.lock.RLock()
+ defer hub.lock.RUnlock()
+
+ // If the account contains the device URL, flatten it to make sure
+ var id uint16
+ if acc.URL != "" {
+ if parts := strings.Split(acc.URL, "."); len(parts) == 2 {
+ bus, busErr := strconv.Atoi(parts[0])
+ addr, addrErr := strconv.Atoi(parts[1])
+
+ if busErr == nil && addrErr == nil {
+ id = uint16(bus)<<8 + uint16(addr)
+ }
+ }
+ }
+ // If the id is still zero, URL is either missing or bad, resolve
+ if id == 0 {
+ var ok bool
+ if id, ok = hub.index[acc.Address]; !ok {
+ return nil, accounts.ErrUnknownAccount
+ }
+ }
+ // Retrieve the wallet associated with the URL
+ wallet, ok := hub.wallets[id]
+ if !ok {
+ return nil, accounts.ErrUnknownAccount
+ }
+ // Ensure the wallet is capable of signing the given transaction
+ if chainID != nil && wallet.version[0] <= 1 && wallet.version[1] <= 0 && wallet.version[2] <= 2 {
+ return nil, fmt.Errorf("Ledger v%d.%d.%d doesn't support signing this transaction, please update to v1.0.3 at least",
+ wallet.version[0], wallet.version[1], wallet.version[2])
+ }
+ return wallet.sign(tx, chainID)
+}
+
+// SignHashWithPassphrase is not supported for Ledger wallets, so this method
+// will always return an error.
+func (hub *LedgerHub) SignHashWithPassphrase(acc accounts.Account, passphrase string, hash []byte) ([]byte, error) {
+ return nil, accounts.ErrNotSupported
+}
+
+// SignTxWithPassphrase requests the backend to sign the given transaction, with the
+// given passphrase as extra authentication information. Since the Ledger does not
+// support this feature, it will just silently ignore the passphrase.
+func (hub *LedgerHub) SignTxWithPassphrase(acc accounts.Account, passphrase string, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
+ return hub.SignTx(acc, tx, chainID)
+}
+
+// Close terminates the usb watching for Ledger wallets and returns when it
+// successfully terminated.
+func (hub *LedgerHub) Close() error {
+ // Terminate the USB scanner
+ errc := make(chan error)
+ hub.quit <- errc
+ err := <-errc
+
+ // Release the USB interface and return
+ hub.ctx.Close()
+ return err
+}
+
+// watch starts watching the local machine's USB ports for the connection or
+// disconnection of Ledger devices.
+func (hub *LedgerHub) watch() {
+ for {
+ // Rescan the USB ports for devices newly added or removed
+ hub.rescan()
+
+ // Sleep for a certain amount of time or until terminated
+ select {
+ case errc := <-hub.quit:
+ errc <- nil
+ return
+ case <-time.After(time.Second):
+ }
+ }
+}
+
+// rescan searches the USB ports for attached Ledger hardware wallets.
+func (hub *LedgerHub) rescan() {
+ hub.lock.Lock()
+ defer hub.lock.Unlock()
+
+ // Iterate over all attached devices and fetch those seemingly Ledger
+ present := make(map[uint16]bool)
+ devices, _ := hub.ctx.ListDevices(func(desc *usb.Descriptor) bool {
+ // Discard all devices not advertizing as Ledger
+ ledger := false
+ for _, id := range ledgerDeviceIDs {
+ if desc.Vendor == id.Vendor && desc.Product == id.Product {
+ ledger = true
+ }
+ }
+ if !ledger {
+ return false
+ }
+ // If we have a Ledger, mark as still present, or open as new
+ id := uint16(desc.Bus)<<8 + uint16(desc.Address)
+ if _, known := hub.wallets[id]; known {
+ // Track it's presence, but don't open again
+ present[id] = true
+ return false
+ }
+ // New Ledger device, open it for communication
+ return true
+ })
+ // Drop any tracker wallet which disconnected
+ for id, wallet := range hub.wallets {
+ if !present[id] {
+ if wallet.address == (common.Address{}) {
+ glog.V(logger.Info).Infof("ledger wallet [%03d.%03d] disconnected", wallet.device.Bus, wallet.device.Address)
+ } else {
+ // A live account disconnected, remove it from the tracked accounts
+ for i, account := range hub.accounts {
+ if account.Address == wallet.address && account.URL == wallet.url {
+ hub.accounts = append(hub.accounts[:i], hub.accounts[i+1:]...)
+ break
+ }
+ }
+ delete(hub.index, wallet.address)
+
+ glog.V(logger.Info).Infof("ledger wallet [%03d.%03d] v%d.%d.%d disconnected: %s", wallet.device.Bus, wallet.device.Address,
+ wallet.version[0], wallet.version[1], wallet.version[2], wallet.address.Hex())
+ }
+ delete(hub.wallets, id)
+ wallet.device.Close()
+ }
+ }
+ // Start tracking all wallets which newly appeared
+ var err error
+ for _, device := range devices {
+ // Make sure the alleged device has the correct IO endpoints
+ wallet := &ledgerWallet{
+ device: device,
+ url: fmt.Sprintf("%03d.%03d", device.Bus, device.Address),
+ }
+ var invalid string
+ switch {
+ case len(device.Descriptor.Configs) == 0:
+ invalid = "no endpoint config available"
+ case len(device.Descriptor.Configs[0].Interfaces) == 0:
+ invalid = "no endpoint interface available"
+ case len(device.Descriptor.Configs[0].Interfaces[0].Setups) == 0:
+ invalid = "no endpoint setup available"
+ case len(device.Descriptor.Configs[0].Interfaces[0].Setups[0].Endpoints) < 2:
+ invalid = "not enough IO endpoints available"
+ }
+ if invalid != "" {
+ glog.V(logger.Debug).Infof("ledger wallet [%s] deemed invalid: %s", wallet.url, invalid)
+ device.Close()
+ continue
+ }
+ // Open the input and output endpoints to the device
+ wallet.input, err = device.OpenEndpoint(
+ device.Descriptor.Configs[0].Config,
+ device.Descriptor.Configs[0].Interfaces[0].Number,
+ device.Descriptor.Configs[0].Interfaces[0].Setups[0].Number,
+ device.Descriptor.Configs[0].Interfaces[0].Setups[0].Endpoints[1].Address,
+ )
+ if err != nil {
+ glog.V(logger.Debug).Infof("ledger wallet [%s] input open failed: %v", wallet.url, err)
+ device.Close()
+ continue
+ }
+ wallet.output, err = device.OpenEndpoint(
+ device.Descriptor.Configs[0].Config,
+ device.Descriptor.Configs[0].Interfaces[0].Number,
+ device.Descriptor.Configs[0].Interfaces[0].Setups[0].Number,
+ device.Descriptor.Configs[0].Interfaces[0].Setups[0].Endpoints[0].Address,
+ )
+ if err != nil {
+ glog.V(logger.Debug).Infof("ledger wallet [%s] output open failed: %v", wallet.url, err)
+ device.Close()
+ continue
+ }
+ // Start tracking the device as a probably Ledger wallet
+ id := uint16(device.Bus)<<8 + uint16(device.Address)
+ hub.wallets[id] = wallet
+
+ if wallet.resolveVersion() != nil || wallet.resolveAddress() != nil {
+ glog.V(logger.Info).Infof("ledger wallet [%s] connected, Ethereum app not started", wallet.url)
+ } else {
+ hub.accounts = append(hub.accounts, accounts.Account{
+ Address: wallet.address,
+ URL: wallet.url,
+ })
+ hub.index[wallet.address] = id
+
+ glog.V(logger.Info).Infof("ledger wallet [%s] v%d.%d.%d connected: %s", wallet.url,
+ wallet.version[0], wallet.version[1], wallet.version[2], wallet.address.Hex())
+ }
+ }
+}
+
+// resolveVersion retrieves the current version of the Ethereum wallet app running
+// on the Ledger wallet and caches it for future reference.
+//
+// The version retrieval protocol is defined as follows:
+//
+// CLA | INS | P1 | P2 | Lc | Le
+// ----+-----+----+----+----+---
+// E0 | 06 | 00 | 00 | 00 | 04
+//
+// With no input data, and the output data being:
+//
+// Description | Length
+// ---------------------------------------------------+--------
+// Flags 01: arbitrary data signature enabled by user | 1 byte
+// Application major version | 1 byte
+// Application minor version | 1 byte
+// Application patch version | 1 byte
+func (wallet *ledgerWallet) resolveVersion() error {
+ // Send the request and wait for the response
+ reply, err := wallet.exchange(ledgerOpGetConfiguration, 0, 0, nil)
+ if err != nil {
+ return err
+ }
+ if len(reply) != 4 {
+ return errors.New("reply not of correct size")
+ }
+ // Cache the version for future reference
+ copy(wallet.version[:], reply[1:])
+ return nil
+}
+
+// resolveAddress retrieves the currently active Ethereum address from a Ledger
+// wallet and caches it for future reference.
+//
+// The address derivation protocol is defined as follows:
+//
+// CLA | INS | P1 | P2 | Lc | Le
+// ----+-----+----+----+-----+---
+// E0 | 02 | 00 return address
+// 01 display address and confirm before returning
+// | 00: do not return the chain code
+// | 01: return the chain code
+// | var | 00
+//
+// Where the input data is:
+//
+// Description | Length
+// -------------------------------------------------+--------
+// Number of BIP 32 derivations to perform (max 10) | 1 byte
+// First derivation index (big endian) | 4 bytes
+// ... | 4 bytes
+// Last derivation index (big endian) | 4 bytes
+//
+// And the output data is:
+//
+// Description | Length
+// ------------------------+-------------------
+// Public Key length | 1 byte
+// Uncompressed Public Key | arbitrary
+// Ethereum address length | 1 byte
+// Ethereum address | 40 bytes hex ascii
+// Chain code if requested | 32 bytes
+func (wallet *ledgerWallet) resolveAddress() error {
+ // Flatten the derivation path into the Ledger request
+ path := make([]byte, 1+4*len(ledgerDerivationPath))
+ path[0] = byte(len(ledgerDerivationPath))
+ for i, component := range ledgerDerivationPath {
+ binary.BigEndian.PutUint32(path[1+4*i:], component)
+ }
+ // Send the request and wait for the response
+ reply, err := wallet.exchange(ledgerOpRetrieveAddress, ledgerP1DirectlyFetchAddress, ledgerP2DiscardAddressChainCode, path)
+ if err != nil {
+ return err
+ }
+ // Discard the public key, we don't need that for now
+ if len(reply) < 1 || len(reply) < 1+int(reply[0]) {
+ return errors.New("reply lacks public key entry")
+ }
+ reply = reply[1+int(reply[0]):]
+
+ // Extract the Ethereum hex address string
+ if len(reply) < 1 || len(reply) < 1+int(reply[0]) {
+ return errors.New("reply lacks address entry")
+ }
+ hexstr := reply[1 : 1+int(reply[0])]
+
+ // Decode the hex sting into an Ethereum address and return
+ hex.Decode(wallet.address[:], hexstr)
+ return nil
+}
+
+// sign sends the transaction to the Ledger wallet, and waits for the user to
+// confirm or deny the transaction.
+//
+// The transaction signing protocol is defined as follows:
+//
+// CLA | INS | P1 | P2 | Lc | Le
+// ----+-----+----+----+-----+---
+// E0 | 04 | 00: first transaction data block
+// 80: subsequent transaction data block
+// | 00 | variable | variable
+//
+// Where the input for the first transaction block (first 255 bytes) is:
+//
+// Description | Length
+// -------------------------------------------------+----------
+// Number of BIP 32 derivations to perform (max 10) | 1 byte
+// First derivation index (big endian) | 4 bytes
+// ... | 4 bytes
+// Last derivation index (big endian) | 4 bytes
+// RLP transaction chunk | arbitrary
+//
+// And the input for subsequent transaction blocks (first 255 bytes) are:
+//
+// Description | Length
+// ----------------------+----------
+// RLP transaction chunk | arbitrary
+//
+// And the output data is:
+//
+// Description | Length
+// ------------+---------
+// signature V | 1 byte
+// signature R | 32 bytes
+// signature S | 32 bytes
+func (wallet *ledgerWallet) sign(tx *types.Transaction, chainID *big.Int) (*types.Transaction, error) {
+ // We need to modify the timeouts to account for user feedback
+ defer func(old time.Duration) { wallet.device.ReadTimeout = old }(wallet.device.ReadTimeout)
+ wallet.device.ReadTimeout = time.Minute
+
+ // Flatten the derivation path into the Ledger request
+ path := make([]byte, 1+4*len(ledgerDerivationPath))
+ path[0] = byte(len(ledgerDerivationPath))
+ for i, component := range ledgerDerivationPath {
+ binary.BigEndian.PutUint32(path[1+4*i:], component)
+ }
+ // Create the transaction RLP based on whether legacy or EIP155 signing was requeste
+ var (
+ txrlp []byte
+ err error
+ )
+ if chainID == nil {
+ if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data()}); err != nil {
+ return nil, err
+ }
+ } else {
+ if txrlp, err = rlp.EncodeToBytes([]interface{}{tx.Nonce(), tx.GasPrice(), tx.Gas(), tx.To(), tx.Value(), tx.Data(), chainID, big.NewInt(0), big.NewInt(0)}); err != nil {
+ return nil, err
+ }
+ }
+ payload := append(path, txrlp...)
+
+ // Send the request and wait for the response
+ var (
+ op = ledgerP1InitTransactionData
+ reply []byte
+ )
+ for len(payload) > 0 {
+ // Calculate the size of the next data chunk
+ chunk := 255
+ if chunk > len(payload) {
+ chunk = len(payload)
+ }
+ // Send the chunk over, ensuring it's processed correctly
+ reply, err = wallet.exchange(ledgerOpSignTransaction, op, 0, payload[:chunk])
+ if err != nil {
+ return nil, err
+ }
+ // Shift the payload and ensure subsequent chunks are marked as such
+ payload = payload[chunk:]
+ op = ledgerP1ContTransactionData
+ }
+ // Extract the Ethereum signature and do a sanity validation
+ if len(reply) != 65 {
+ return nil, errors.New("reply lacks signature")
+ }
+ signature := append(reply[1:], reply[0])
+
+ // Create the correct signer and signature transform based on the chain ID
+ var signer types.Signer
+ if chainID == nil {
+ signer = new(types.HomesteadSigner)
+ } else {
+ signer = types.NewEIP155Signer(chainID)
+ signature[64] = (signature[64]-34)/2 - byte(chainID.Uint64())
+ }
+ // Inject the final signature into the transaction and sanity check the sender
+ signed, err := tx.WithSignature(signer, signature)
+ if err != nil {
+ return nil, err
+ }
+ sender, err := types.Sender(signer, signed)
+ if err != nil {
+ return nil, err
+ }
+ if sender != wallet.address {
+ glog.V(logger.Error).Infof("Ledger signer mismatch: expected %s, got %s", wallet.address.Hex(), sender.Hex())
+ return nil, fmt.Errorf("signer mismatch: expected %s, got %s", wallet.address.Hex(), sender.Hex())
+ }
+ return signed, nil
+}
+
+// exchange performs a data exchange with the Ledger wallet, sending it a message
+// and retrieving the response.
+//
+// The common transport header is defined as follows:
+//
+// Description | Length
+// --------------------------------------+----------
+// Communication channel ID (big endian) | 2 bytes
+// Command tag | 1 byte
+// Packet sequence index (big endian) | 2 bytes
+// Payload | arbitrary
+//
+// The Communication channel ID allows commands multiplexing over the same
+// physical link. It is not used for the time being, and should be set to 0101
+// to avoid compatibility issues with implementations ignoring a leading 00 byte.
+//
+// The Command tag describes the message content. Use TAG_APDU (0x05) for standard
+// APDU payloads, or TAG_PING (0x02) for a simple link test.
+//
+// The Packet sequence index describes the current sequence for fragmented payloads.
+// The first fragment index is 0x00.
+//
+// APDU Command payloads are encoded as follows:
+//
+// Description | Length
+// -----------------------------------
+// APDU length (big endian) | 2 bytes
+// APDU CLA | 1 byte
+// APDU INS | 1 byte
+// APDU P1 | 1 byte
+// APDU P2 | 1 byte
+// APDU length | 1 byte
+// Optional APDU data | arbitrary
+func (wallet *ledgerWallet) exchange(opcode ledgerOpcode, p1 ledgerParam1, p2 ledgerParam2, data []byte) ([]byte, error) {
+ // Construct the message payload, possibly split into multiple chunks
+ var chunks [][]byte
+ for left := data; len(left) > 0 || len(chunks) == 0; {
+ // Create the chunk header
+ var chunk []byte
+
+ if len(chunks) == 0 {
+ // The first chunk encodes the length and all the opcodes
+ chunk = []byte{0x00, 0x00, 0xe0, byte(opcode), byte(p1), byte(p2), byte(len(data))}
+ binary.BigEndian.PutUint16(chunk, uint16(5+len(data)))
+ }
+ // Append the data blob to the end of the chunk
+ space := 64 - len(chunk) - 5 // 5 == header size
+ if len(left) > space {
+ chunks, left = append(chunks, append(chunk, left[:space]...)), left[space:]
+ continue
+ }
+ chunks, left = append(chunks, append(chunk, left...)), nil
+ }
+ // Stream all the chunks to the device
+ for i, chunk := range chunks {
+ // Construct the new message to stream
+ header := []byte{0x01, 0x01, 0x05, 0x00, 0x00} // Channel ID and command tag appended
+ binary.BigEndian.PutUint16(header[3:], uint16(i))
+
+ msg := append(header, chunk...)
+
+ // Send over to the device
+ if glog.V(logger.Core) {
+ glog.Infof("-> %03d.%03d: %x", wallet.device.Bus, wallet.device.Address, msg)
+ }
+ if _, err := wallet.input.Write(msg); err != nil {
+ return nil, err
+ }
+ }
+ // Stream the reply back from the wallet in 64 byte chunks
+ var reply []byte
+ for {
+ // Read the next chunk from the Ledger wallet
+ chunk := make([]byte, 64)
+ if _, err := io.ReadFull(wallet.output, chunk); err != nil {
+ return nil, err
+ }
+ if glog.V(logger.Core) {
+ glog.Infof("<- %03d.%03d: %x", wallet.device.Bus, wallet.device.Address, chunk)
+ }
+ // Make sure the transport header matches
+ if chunk[0] != 0x01 || chunk[1] != 0x01 || chunk[2] != 0x05 {
+ return nil, fmt.Errorf("invalid reply header: %x", chunk[:3])
+ }
+ // If it's the first chunk, retrieve the total message length
+ if chunk[3] == 0x00 && chunk[4] == 0x00 {
+ reply = make([]byte, 0, int(binary.BigEndian.Uint16(chunk[5:7])))
+ chunk = chunk[7:]
+ } else {
+ chunk = chunk[5:]
+ }
+ // Append to the reply and stop when filled up
+ if left := cap(reply) - len(reply); left > len(chunk) {
+ reply = append(reply, chunk...)
+ } else {
+ reply = append(reply, chunk[:left]...)
+ break
+ }
+ }
+ return reply[:len(reply)-2], nil
+}
diff --git a/accounts/usbwallet/ledger_test.go b/accounts/usbwallet/ledger_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..aeab2f0f022881e9c504bf44e3bf27f483e6fbde
--- /dev/null
+++ b/accounts/usbwallet/ledger_test.go
@@ -0,0 +1,75 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+package usbwallet
+
+/*
+func TestLedgerHub(t *testing.T) {
+ glog.SetV(6)
+ glog.SetToStderr(true)
+
+ // Create a USB hub watching for Ledger devices
+ hub, err := NewLedgerHub()
+ if err != nil {
+ t.Fatalf("Failed to create Ledger hub: %v", err)
+ }
+ defer hub.Close()
+
+ // Wait for events :P
+ time.Sleep(time.Minute)
+}
+*/
+/*
+func TestLedger(t *testing.T) {
+ // Create a USB context to access devices through
+ ctx, err := usb.NewContext()
+ defer ctx.Close()
+ ctx.Debug(6)
+
+ // List all of the Ledger wallets
+ wallets, err := findLedgerWallets(ctx)
+ if err != nil {
+ t.Fatalf("Failed to list Ledger wallets: %v", err)
+ }
+ // Retrieve the address from every one of them
+ for _, wallet := range wallets {
+ // Retrieve the version of the wallet app
+ ver, err := wallet.Version()
+ if err != nil {
+ t.Fatalf("Failed to retrieve wallet version: %v", err)
+ }
+ fmt.Printf("Ledger version: %s\n", ver)
+
+ // Retrieve the address of the wallet
+ addr, err := wallet.Address()
+ if err != nil {
+ t.Fatalf("Failed to retrieve wallet address: %v", err)
+ }
+ fmt.Printf("Ledger address: %x\n", addr)
+
+ // Try to sign a transaction with the wallet
+ unsigned := types.NewTransaction(1, common.HexToAddress("0xbabababababababababababababababababababa"), common.Ether, big.NewInt(20000), common.Shannon, nil)
+ signed, err := wallet.Sign(unsigned)
+ if err != nil {
+ t.Fatalf("Failed to sign transactions: %v", err)
+ }
+ signer, err := types.Sender(types.NewEIP155Signer(big.NewInt(1)), signed)
+ if err != nil {
+ t.Fatalf("Failed to recover signer: %v", err)
+ }
+ fmt.Printf("Ledger signature by: %x\n", signer)
+ }
+}*/
diff --git a/accounts/usbwallet/usb.go b/accounts/usbwallet/usb.go
new file mode 100644
index 0000000000000000000000000000000000000000..550f05ba652099050aa9b1f31a9f068bf4bf3784
--- /dev/null
+++ b/accounts/usbwallet/usb.go
@@ -0,0 +1,27 @@
+// Copyright 2017 The go-ethereum Authors
+// This file is part of the go-ethereum library.
+//
+// The go-ethereum library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// The go-ethereum library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
+
+// Package usbwallet implements support for USB hardware wallets.
+package usbwallet
+
+import "github.com/karalabe/gousb/usb"
+
+// deviceID is a combined vendor/product identifier to uniquely identify a USB
+// hardware device.
+type deviceID struct {
+ Vendor usb.ID // The Vendor identifer
+ Product usb.ID // The Product identifier
+}
diff --git a/node/config.go b/node/config.go
index f3b4dcc7319768871076da3249b575473731d9d5..9ae9406a90ac09d91c76b88dad892644e4b626f2 100644
--- a/node/config.go
+++ b/node/config.go
@@ -28,6 +28,7 @@ import (
"github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/accounts/keystore"
+ "github.com/ethereum/go-ethereum/accounts/usbwallet"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/logger"
@@ -432,6 +433,15 @@ func makeAccountManager(conf *Config) (am *accounts.Manager, ephemeralKeystore s
if err := os.MkdirAll(keydir, 0700); err != nil {
return nil, "", err
}
- ks := keystore.NewKeyStore(keydir, scryptN, scryptP)
- return accounts.NewManager(ks), ephemeralKeystore, nil
+
+ // Assemble the account manager and supported backends
+ backends := []accounts.Backend{
+ keystore.NewKeyStore(keydir, scryptN, scryptP),
+ }
+ if ledgerhub, err := usbwallet.NewLedgerHub(); err != nil {
+ glog.V(logger.Warn).Infof("Failed to start Ledger hub, disabling: %v", err)
+ } else {
+ backends = append(backends, ledgerhub)
+ }
+ return accounts.NewManager(backends...), ephemeralKeystore, nil
}