wallet

Documentation

Index

• Constants
• Variables
• type Backend
• type CryptoJSON
• type DSBackend
  • func NewDSBackend(ds repo.Datastore, passphraseCfg config.PassphraseConfig) (*DSBackend, error)
  • func (backend *DSBackend) Addresses() []address.Address
  • func (backend *DSBackend) GetKeyInfo(addr address.Address) (*crypto.KeyInfo, error)
  • func (backend *DSBackend) GetKeyInfoPassphrase(addr address.Address, password []byte) (*crypto.KeyInfo, error)
  • func (backend *DSBackend) HasAddress(addr address.Address) bool
  • func (backend *DSBackend) HavePassword() bool
  • func (backend *DSBackend) ImportKey(ki *crypto.KeyInfo) error
  • func (backend *DSBackend) Locked(password string) error
  • func (backend *DSBackend) NewAddress(protocol address.Protocol) (address.Address, error)
  • func (backend *DSBackend) SetPassword(password string) error
  • func (backend *DSBackend) SignBytes(data []byte, addr address.Address) (*crypto.Signature, error)
  • func (backend *DSBackend) UnLocked(password string) error
• type Importer
• type KeccakState
• type Key
  • func (k *Key) MarshalJSON() (j []byte, err error)
  • func (k *Key) UnmarshalJSON(j []byte) (err error)
• type MsgMeta
• type MsgType
• type Wallet
  • func New(backends ...Backend) *Wallet
  • func (w *Wallet) Addresses() []address.Address
  • func (w *Wallet) Backends(kind reflect.Type) []Backend
  • func (w *Wallet) DSBacked() (*DSBackend, error)
  • func (w *Wallet) Export(addr address.Address, password string) (*crypto.KeyInfo, error)
  • func (w *Wallet) Find(addr address.Address) (Backend, error)
  • func (w *Wallet) GetPubKeyForAddress(addr address.Address) ([]byte, error)
  • func (w *Wallet) HasAddress(a address.Address) bool
  • func (w *Wallet) HavePassword() bool
  • func (w *Wallet) Import(ki *crypto.KeyInfo) (address.Address, error)
  • func (w *Wallet) Locked(password string) error
  • func (w *Wallet) NewAddress(p address.Protocol) (address.Address, error)
  • func (w *Wallet) NewKeyInfo() (*crypto.KeyInfo, error)
  • func (w *Wallet) SetPassword(password string) error
  • func (w *Wallet) SignBytes(data []byte, addr address.Address) (*crypto.Signature, error)
  • func (w *Wallet) UnLocked(password string) error
  • func (w *Wallet) WalletSign(ctx context.Context, addr address.Address, msg []byte, meta MsgMeta) (*crypto.Signature, error)

Constants

const (
	MTUnknown = "unknown"

	// Signing message CID. MsgMeta.Extra contains raw cbor message bytes
	MTChainMsg = "message"

	// Signing a blockheader. signing raw cbor block bytes (MsgMeta.Extra is empty)
	MTBlock = "block"

	// Signing a deal proposal. signing raw cbor proposal bytes (MsgMeta.Extra is empty)
	MTDealProposal = "dealproposal"
)

const TestPassword = "test-password"

Variables

var DSBackendType = reflect.TypeOf(&DSBackend{})

DSBackendType is the reflect type of the DSBackend.

var ErrDecrypt = errors.New("could not decrypt key with given password")

var ErrInvalidPassword = errors.New("password matching failed")

var ErrKeyInfoNotFound = fmt.Errorf("key info not found")

var ErrRepeatPassword = errors.New("set password more than once")

Types

type Backend

type Backend interface {
	// Addresses returns a list of all accounts currently stored in this backend.
	Addresses() []address.Address

	// Contains returns true if this backend stores the passed in address.
	HasAddress(address.Address) bool

	// Sign cryptographically signs data with the private key associated with an address.
	SignBytes([]byte, address.Address) (*crypto.Signature, error)

	// GetKeyInfo will return the keyinfo associated with address `addr`
	// iff backend contains the addr.
	GetKeyInfo(address.Address) (*crypto.KeyInfo, error)

	GetKeyInfoPassphrase(address.Address, []byte) (*crypto.KeyInfo, error)

	//
	Locked(string) error
	UnLocked(string) error
}

Backend is the interface to represent different storage backends that can contain many addresses.

type CryptoJSON

type CryptoJSON struct {
	Cipher       string                 `json:"cipher"`
	CipherText   string                 `json:"ciphertext"`
	CipherParams cipherParams           `json:"cipherparams"`
	KDF          string                 `json:"kdf"`
	KDFParams    map[string]interface{} `json:"kdfparams"`
	MAC          string                 `json:"mac"`
}

type DSBackend

type DSBackend struct {
	PassphraseConf config.PassphraseConfig
	// contains filtered or unexported fields
}

DSBackend is a wallet backend implementation for storing addresses in a datastore.

func NewDSBackend

func NewDSBackend(ds repo.Datastore, passphraseCfg config.PassphraseConfig) (*DSBackend, error)

NewDSBackend constructs a new backend using the passed in datastore.

func (*DSBackend) Addresses

func (backend *DSBackend) Addresses() []address.Address

Addresses returns a list of all addresses that are stored in this backend.

func (*DSBackend) GetKeyInfo

func (backend *DSBackend) GetKeyInfo(addr address.Address) (*crypto.KeyInfo, error)

GetKeyInfo will return the private & public keys associated with address `addr` iff backend contains the addr.

func (*DSBackend) GetKeyInfoPassphrase

func (backend *DSBackend) GetKeyInfoPassphrase(addr address.Address, password []byte) (*crypto.KeyInfo, error)

func (*DSBackend) HasAddress

func (backend *DSBackend) HasAddress(addr address.Address) bool

HasAddress checks if the passed in address is stored in this backend. Safe for concurrent access.

func (*DSBackend) HavePassword

func (backend *DSBackend) HavePassword() bool

func (*DSBackend) ImportKey

func (backend *DSBackend) ImportKey(ki *crypto.KeyInfo) error

ImportKey loads the address in `ai` and KeyInfo `ki` into the backend

func (*DSBackend) Locked

func (backend *DSBackend) Locked(password string) error

func (*DSBackend) NewAddress

func (backend *DSBackend) NewAddress(protocol address.Protocol) (address.Address, error)

NewAddress creates a new address and stores it. Safe for concurrent access.

func (*DSBackend) SetPassword

func (backend *DSBackend) SetPassword(password string) error

func (*DSBackend) SignBytes

func (backend *DSBackend) SignBytes(data []byte, addr address.Address) (*crypto.Signature, error)

SignBytes cryptographically signs `data` using the private key `priv`.

func (*DSBackend) UnLocked

func (backend *DSBackend) UnLocked(password string) error

type Importer

type Importer interface {
	// ImportKey imports the key described by the given keyinfo
	// into the backend
	ImportKey(*crypto.KeyInfo) error
}

Importer is a specialization of a wallet backend that can import new keys into its permanent storage. Disk backed wallets can do this, hardware wallets generally cannot.

type KeccakState

type KeccakState interface {
	hash.Hash
	Read([]byte) (int, error)
}

KeccakState wraps sha3.state. In addition to the usual hash methods, it also supports Read to get a variable amount of data from the hash state. Read is faster than Sum because it doesn't copy the internal state, but also modifies the internal state.

type Key

type Key struct {
	ID uuid.UUID // Version 4 "random" for unique id not derived from key data
	// to simplify lookups we also store the address
	Address address.Address
	KeyInfo *crypto.KeyInfo
}

func (*Key) MarshalJSON

func (k *Key) MarshalJSON() (j []byte, err error)

func (*Key) UnmarshalJSON

func (k *Key) UnmarshalJSON(j []byte) (err error)

type MsgMeta

type MsgMeta struct {
	Type MsgType

	// Additional data related to what is signed. Should be verifiable with the
	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
	Extra []byte
}

type MsgType

type MsgType string

type Wallet

type Wallet struct {
	// contains filtered or unexported fields
}

wallet manages the locally stored addresses.

func New

func New(backends ...Backend) *Wallet

New constructs a new wallet, that manages addresses in all the passed in backends.

func (*Wallet) Addresses

func (w *Wallet) Addresses() []address.Address

Addresses retrieves all stored addresses. Safe for concurrent access. Always sorted in the same order.

func (*Wallet) Backends

func (w *Wallet) Backends(kind reflect.Type) []Backend

Backends returns backends by their kind.

func (*Wallet) DSBacked

func (w *Wallet) DSBacked() (*DSBackend, error)

func (*Wallet) Export

func (w *Wallet) Export(addr address.Address, password string) (*crypto.KeyInfo, error)

Export returns the KeyInfos for the given wallet addresses

func (*Wallet) Find

func (w *Wallet) Find(addr address.Address) (Backend, error)

Find searches through all backends and returns the one storing the passed in address. Safe for concurrent access.

func (*Wallet) GetPubKeyForAddress

func (w *Wallet) GetPubKeyForAddress(addr address.Address) ([]byte, error)

GetPubKeyForAddress returns the public key in the keystore associated with the given address.

func (*Wallet) HasAddress

func (w *Wallet) HasAddress(a address.Address) bool

HasAddress checks if the given address is stored. Safe for concurrent access.

func (*Wallet) HavePassword

func (w *Wallet) HavePassword() bool

func (*Wallet) Import

func (w *Wallet) Import(ki *crypto.KeyInfo) (address.Address, error)

Import adds the given keyinfo to the wallet

func (*Wallet) Locked

func (w *Wallet) Locked(password string) error

func (*Wallet) NewAddress

func (w *Wallet) NewAddress(p address.Protocol) (address.Address, error)

NewAddress creates a new account address on the default wallet backend.

func (*Wallet) NewKeyInfo

func (w *Wallet) NewKeyInfo() (*crypto.KeyInfo, error)

NewKeyInfo creates a new KeyInfo struct in the wallet backend and returns it

func (*Wallet) SetPassword

func (w *Wallet) SetPassword(password string) error

func (*Wallet) SignBytes

func (w *Wallet) SignBytes(data []byte, addr address.Address) (*crypto.Signature, error)

SignBytes cryptographically signs `data` using the private key corresponding to address `addr`

func (*Wallet) UnLocked

func (w *Wallet) UnLocked(password string) error

func (*Wallet) WalletSign

func (w *Wallet) WalletSign(ctx context.Context, addr address.Address, msg []byte, meta MsgMeta) (*crypto.Signature, error)