keystore

Documentation

Index

• Variables
• func NewORM(db *sqlx.DB, lggr logger.Logger, cfg pg.LogConfig) ksORM
• type CSA
• type DKGSign
• type DefaultEVMChainIDFunc
• type Eth
• type Key
• type KeyNotFoundError
  • func (e KeyNotFoundError) Error() string
• type Master
  • func New(db *sqlx.DB, scryptParams utils.ScryptParams, lggr logger.Logger, ...) Master
• type OCR
• type OCR2
• type P2P
• type Solana
• type StarkNet
• type Terra
• type VRF

Variables

var ErrCSAKeyExists = errors.New("can only have 1 CSA key")

ErrCSAKeyExists describes the error when the CSA key already exists

var ErrLocked = errors.New("Keystore is locked")

var (
	ErrMissingVRFKey = errors.New("unable to find VRF key")
)

var (
	ErrNoP2PKey = errors.New("no p2p keys exist")
)

var (
	ErrNoSolanaKey = errors.New("no solana keys exist")
)

var (
	ErrNoStarkNetKey = errors.New("no starknet keys exist")
)

var (
	ErrNoTerraKey = errors.New("no terra keys exist")
)

Functions

func NewORM

func NewORM(db *sqlx.DB, lggr logger.Logger, cfg pg.LogConfig) ksORM

Types

type CSA

type CSA interface {
	Get(id string) (csakey.KeyV2, error)
	GetAll() ([]csakey.KeyV2, error)
	Create() (csakey.KeyV2, error)
	Add(key csakey.KeyV2) error
	Delete(id string) (csakey.KeyV2, error)
	Import(keyJSON []byte, password string) (csakey.KeyV2, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error

	GetV1KeysAsV2() ([]csakey.KeyV2, error)
}

type CSAKeystoreInterface interface {

type DKGSign

type DKGSign interface {
	Get(id string) (dkgsignkey.Key, error)
	GetAll() ([]dkgsignkey.Key, error)
	Create() (dkgsignkey.Key, error)
	Add(key dkgsignkey.Key) error
	Delete(id string) (dkgsignkey.Key, error)
	Import(keyJSON []byte, password string) (dkgsignkey.Key, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error
}

DKGSign provides signing keys for the DKG.

type DefaultEVMChainIDFunc

type DefaultEVMChainIDFunc func() (defaultEVMChainID *big.Int, err error)

DefaultEVMChainIDFunc is a func for getting a default evm chain ID - necessary because it is lazily evaluated

type Eth

type Eth interface {
	Get(id string) (ethkey.KeyV2, error)
	GetAll() ([]ethkey.KeyV2, error)
	Create(chainID *big.Int) (ethkey.KeyV2, error)
	Add(key ethkey.KeyV2, chainID *big.Int) error
	Delete(id string) (ethkey.KeyV2, error)
	Import(keyJSON []byte, password string, chainID *big.Int) (ethkey.KeyV2, error)
	Export(id string, password string) ([]byte, error)

	EnsureKeys(chainID *big.Int) error
	SubscribeToKeyChanges() (ch chan struct{}, unsub func())

	SignTx(fromAddress common.Address, tx *types.Transaction, chainID *big.Int) (*types.Transaction, error)

	SendingKeys(chainID *big.Int) (keys []ethkey.KeyV2, err error)
	FundingKeys() (keys []ethkey.KeyV2, err error)
	GetRoundRobinAddress(chainID *big.Int, addresses ...common.Address) (address common.Address, err error)

	GetState(id string) (ethkey.State, error)
	SetState(ethkey.State) error
	GetStatesForKeys([]ethkey.KeyV2) ([]ethkey.State, error)
	GetStatesForChain(chainID *big.Int) ([]ethkey.State, error)

	GetV1KeysAsV2(f DefaultEVMChainIDFunc) ([]ethkey.KeyV2, []ethkey.State, error)
}

Eth is the external interface for EthKeyStore

type Key

type Key interface {
	ID() string
}

type KeyNotFoundError

type KeyNotFoundError struct {
	ID      string
	KeyType string
}

KeyNotFoundError is returned when we don't find a requested key

func (KeyNotFoundError) Error

func (e KeyNotFoundError) Error() string

type Master

type Master interface {
	CSA() CSA
	DKGSign() DKGSign
	Eth() Eth
	OCR() OCR
	OCR2() OCR2
	P2P() P2P
	Solana() Solana
	Terra() Terra
	StarkNet() StarkNet
	VRF() VRF
	Unlock(password string) error
	Migrate(vrfPassword string, f DefaultEVMChainIDFunc) error
	IsEmpty() (bool, error)
}

func New

func New(db *sqlx.DB, scryptParams utils.ScryptParams, lggr logger.Logger, cfg pg.LogConfig) Master

type OCR

type OCR interface {
	Get(id string) (ocrkey.KeyV2, error)
	GetAll() ([]ocrkey.KeyV2, error)
	Create() (ocrkey.KeyV2, error)
	Add(key ocrkey.KeyV2) error
	Delete(id string) (ocrkey.KeyV2, error)
	Import(keyJSON []byte, password string) (ocrkey.KeyV2, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error

	GetV1KeysAsV2() ([]ocrkey.KeyV2, error)
}

type OCR2

type OCR2 interface {
	Get(id string) (ocr2key.KeyBundle, error)
	GetAll() ([]ocr2key.KeyBundle, error)
	GetAllOfType(chaintype.ChainType) ([]ocr2key.KeyBundle, error)
	Create(chaintype.ChainType) (ocr2key.KeyBundle, error)
	Add(key ocr2key.KeyBundle) error
	Delete(id string) error
	Import(keyJSON []byte, password string) (ocr2key.KeyBundle, error)
	Export(id string, password string) ([]byte, error)
	EnsureKeys() error
}

type P2P

type P2P interface {
	Get(id p2pkey.PeerID) (p2pkey.KeyV2, error)
	GetAll() ([]p2pkey.KeyV2, error)
	Create() (p2pkey.KeyV2, error)
	Add(key p2pkey.KeyV2) error
	Delete(id p2pkey.PeerID) (p2pkey.KeyV2, error)
	Import(keyJSON []byte, password string) (p2pkey.KeyV2, error)
	Export(id p2pkey.PeerID, password string) ([]byte, error)
	EnsureKey() error

	GetV1KeysAsV2() ([]p2pkey.KeyV2, error)

	GetOrFirst(id p2pkey.PeerID) (p2pkey.KeyV2, error)
}

type Solana

type Solana interface {
	Get(id string) (solkey.Key, error)
	GetAll() ([]solkey.Key, error)
	Create() (solkey.Key, error)
	Add(key solkey.Key) error
	Delete(id string) (solkey.Key, error)
	Import(keyJSON []byte, password string) (solkey.Key, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error
}

type StarkNet

type StarkNet interface {
	Get(id string) (starkkey.Key, error)
	GetAll() ([]starkkey.Key, error)
	Create() (starkkey.Key, error)
	Add(key starkkey.Key) error
	Delete(id string) (starkkey.Key, error)
	Import(keyJSON []byte, password string) (starkkey.Key, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error
}

type Terra

type Terra interface {
	Get(id string) (terrakey.Key, error)
	GetAll() ([]terrakey.Key, error)
	Create() (terrakey.Key, error)
	Add(key terrakey.Key) error
	Delete(id string) (terrakey.Key, error)
	Import(keyJSON []byte, password string) (terrakey.Key, error)
	Export(id string, password string) ([]byte, error)
	EnsureKey() error
}

type VRF

type VRF interface {
	Get(id string) (vrfkey.KeyV2, error)
	GetAll() ([]vrfkey.KeyV2, error)
	Create() (vrfkey.KeyV2, error)
	Add(key vrfkey.KeyV2) error
	Delete(id string) (vrfkey.KeyV2, error)
	Import(keyJSON []byte, password string) (vrfkey.KeyV2, error)
	Export(id string, password string) ([]byte, error)

	GenerateProof(id string, seed *big.Int) (vrfkey.Proof, error)

	GetV1KeysAsV2(password string) ([]vrfkey.KeyV2, error)
}