accounts

Documentation

Overview

Package accounts implements high level Ethereum account management.

Index

• type Account
• type Backend
• type Wallet

Types

type Account

type Account struct {
	Address   common.Address   `json:"address"`   // Ethereum account address derived from the key
	PublicKey *ecdsa.PublicKey `json:"publicKey"` // Public key corresponding to the account address
}

Account represents an Ethereum account located at a specific location defined by the optional URL field.

type Backend

type Backend interface {
	// Wallets retrieves the list of wallets the backend is currently aware of.
	//
	// The returned wallets are not opened by default. For software HD wallets this
	// means that no base seeds are decrypted, and for hardware wallets that no actual
	// connection is established.
	//
	// The resulting wallet list will be sorted alphabetically based on its internal
	// URL assigned by the backend. Since wallets (especially hardware) may come and
	// go, the same wallet might appear at a different positions in the list during
	// subsequent retrievals.
	Wallets() []Wallet
}

Backend is a "wallet provider" that may contain a batch of accounts they can sign transactions with and upon request, do so.

type Wallet

type Wallet interface {
	// URL retrieves the canonical path under which this wallet is reachable. It is
	// used by upper layers to define a sorting order over all wallets from multiple
	// backends.
	URL() gethaccounts.URL

	// Status returns a textual status to aid the user in the current state of the
	// wallet. It also returns an error indicating any failure the wallet might have
	// encountered.
	Status() (string, error)

	// Open initializes access to a wallet instance. It is not meant to unlock or
	// decrypt account keys, rather simply to establish a connection to hardware
	// wallets and/or to access derivation seeds.
	//
	// The passphrase parameter may or may not be used by the implementation of a
	// particular wallet instance. The reason there is no password-less open method
	// is to strive towards a uniform wallet handling, oblivious to the different
	// backend providers.
	//
	// Please note, if you open a wallet, you must close it to release any allocated
	// resources (especially important when working with hardware wallets).
	Open(passphrase string) error

	// Close releases any resources held by an open wallet instance.
	Close() error

	// Accounts retrieves the list of signing accounts the wallet is currently aware
	// of. For hierarchical deterministic wallets, the list will not be exhaustive,
	// rather only contain the accounts explicitly pinned during account derivation.
	Accounts() []Account

	// Contains returns whether an account is part of this particular wallet or not.
	Contains(account Account) bool

	// Derive attempts to explicitly derive a hierarchical deterministic account at
	// the specified derivation path. If requested, the derived account will be added
	// to the wallet's tracked account list.
	Derive(path gethaccounts.DerivationPath, pin bool) (Account, error)

	// SignTypedData signs a TypedData object using EIP-712 encoding
	SignTypedData(account Account, typedData apitypes.TypedData) ([]byte, error)
}

Wallet represents a software or hardware wallet that might contain one or more accounts (derived from the same seed).