github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/libs/cosmos-sdk/crypto/keys/lazy_keybase.go (about)

     1  package keys
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/cosmos/go-bip39"
     7  	"github.com/fibonacci-chain/fbc/libs/tendermint/crypto"
     8  	tmos "github.com/fibonacci-chain/fbc/libs/tendermint/libs/os"
     9  
    10  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
    11  )
    12  
    13  var _ Keybase = lazyKeybase{}
    14  
    15  // NOTE: lazyKeybase will be deprecated in favor of lazyKeybaseKeyring.
    16  type lazyKeybase struct {
    17  	name    string
    18  	dir     string
    19  	options []KeybaseOption
    20  }
    21  
    22  // New creates a new instance of a lazy keybase.
    23  func New(name, dir string, opts ...KeybaseOption) Keybase {
    24  	if err := tmos.EnsureDir(dir, 0700); err != nil {
    25  		panic(fmt.Sprintf("failed to create Keybase directory: %s", err))
    26  	}
    27  
    28  	return lazyKeybase{name: name, dir: dir, options: opts}
    29  }
    30  
    31  func (lkb lazyKeybase) List() ([]Info, error) {
    32  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    33  	if err != nil {
    34  		return nil, err
    35  	}
    36  	defer db.Close()
    37  
    38  	return newDBKeybase(db, lkb.options...).List()
    39  }
    40  
    41  func (lkb lazyKeybase) Get(name string) (Info, error) {
    42  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    43  	if err != nil {
    44  		return nil, err
    45  	}
    46  	defer db.Close()
    47  
    48  	return newDBKeybase(db, lkb.options...).Get(name)
    49  }
    50  
    51  func (lkb lazyKeybase) GetByAddress(address sdk.AccAddress) (Info, error) {
    52  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    53  	if err != nil {
    54  		return nil, err
    55  	}
    56  	defer db.Close()
    57  
    58  	return newDBKeybase(db, lkb.options...).GetByAddress(address)
    59  }
    60  
    61  func (lkb lazyKeybase) Delete(name, passphrase string, skipPass bool) error {
    62  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    63  	if err != nil {
    64  		return err
    65  	}
    66  	defer db.Close()
    67  
    68  	return newDBKeybase(db, lkb.options...).Delete(name, passphrase, skipPass)
    69  }
    70  
    71  func (lkb lazyKeybase) Sign(name, passphrase string, msg []byte) ([]byte, crypto.PubKey, error) {
    72  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    73  	if err != nil {
    74  		return nil, nil, err
    75  	}
    76  	defer db.Close()
    77  
    78  	return newDBKeybase(db, lkb.options...).Sign(name, passphrase, msg)
    79  }
    80  
    81  func (lkb lazyKeybase) CreateMnemonic(name string, language Language, passwd string, algo SigningAlgo, mnemonicInput string) (info Info, seed string, err error) {
    82  	db, err := sdk.NewDB(lkb.name, lkb.dir)
    83  	if err != nil {
    84  		return nil, "", err
    85  	}
    86  	defer db.Close()
    87  
    88  	return newDBKeybase(db, lkb.options...).CreateMnemonic(name, language, passwd, algo, mnemonicInput)
    89  }
    90  
    91  // CreateMnemonicWithHDPath generates a new key with the given algorithm and language pair.
    92  func (kb lazyKeybase) CreateMnemonicWithHDPath(name string, language Language, passwd string, algo SigningAlgo, mnemonicInput string, hdPath string,
    93  ) (info Info, mnemonic string, err error) {
    94  
    95  	if language != English {
    96  		return nil, "", ErrUnsupportedLanguage
    97  	}
    98  
    99  	if !IsSupportedAlgorithm(kb.SupportedAlgos(), algo) {
   100  		return nil, "", ErrUnsupportedSigningAlgo
   101  	}
   102  
   103  	// Default number of words (24): This generates a mnemonic directly from the
   104  	// number of words by reading system entropy.
   105  	entropy, err := bip39.NewEntropy(defaultEntropySize)
   106  	if err != nil {
   107  		return nil, "", err
   108  	}
   109  
   110  	mnemonic, err = bip39.NewMnemonic(entropy)
   111  	if err != nil {
   112  		return nil, "", err
   113  	}
   114  
   115  	if len(mnemonicInput) > 0 {
   116  		mnemonic = mnemonicInput
   117  	}
   118  
   119  	info, err = kb.CreateAccount(name, mnemonic, DefaultBIP39Passphrase, passwd, hdPath, algo)
   120  	if err != nil {
   121  		return nil, "", err
   122  	}
   123  
   124  	return info, mnemonic, err
   125  }
   126  
   127  func (lkb lazyKeybase) CreateAccount(name, mnemonic, bip39Passwd, encryptPasswd, hdPath string, algo SigningAlgo) (Info, error) {
   128  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   129  	if err != nil {
   130  		return nil, err
   131  	}
   132  	defer db.Close()
   133  
   134  	return newDBKeybase(db,
   135  		lkb.options...).CreateAccount(name, mnemonic, bip39Passwd, encryptPasswd, hdPath, algo)
   136  }
   137  
   138  func (lkb lazyKeybase) CreateLedger(name string, algo SigningAlgo, hrp string, account, index uint32) (info Info, err error) {
   139  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   140  	if err != nil {
   141  		return nil, err
   142  	}
   143  	defer db.Close()
   144  
   145  	return newDBKeybase(db, lkb.options...).CreateLedger(name, algo, hrp, account, index)
   146  }
   147  
   148  func (lkb lazyKeybase) CreateOffline(name string, pubkey crypto.PubKey, algo SigningAlgo) (info Info, err error) {
   149  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   150  	if err != nil {
   151  		return nil, err
   152  	}
   153  	defer db.Close()
   154  
   155  	return newDBKeybase(db, lkb.options...).CreateOffline(name, pubkey, algo)
   156  }
   157  
   158  func (lkb lazyKeybase) CreateMulti(name string, pubkey crypto.PubKey) (info Info, err error) {
   159  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   160  	if err != nil {
   161  		return nil, err
   162  	}
   163  	defer db.Close()
   164  
   165  	return newDBKeybase(db, lkb.options...).CreateMulti(name, pubkey)
   166  }
   167  
   168  func (lkb lazyKeybase) Update(name, oldpass string, getNewpass func() (string, error)) error {
   169  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   170  	if err != nil {
   171  		return err
   172  	}
   173  	defer db.Close()
   174  
   175  	return newDBKeybase(db, lkb.options...).Update(name, oldpass, getNewpass)
   176  }
   177  
   178  func (lkb lazyKeybase) Import(name string, armor string) (err error) {
   179  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   180  	if err != nil {
   181  		return err
   182  	}
   183  	defer db.Close()
   184  
   185  	return newDBKeybase(db, lkb.options...).Import(name, armor)
   186  }
   187  
   188  func (lkb lazyKeybase) ImportPrivKey(name string, armor string, passphrase string) error {
   189  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   190  	if err != nil {
   191  		return err
   192  	}
   193  	defer db.Close()
   194  
   195  	return newDBKeybase(db, lkb.options...).ImportPrivKey(name, armor, passphrase)
   196  }
   197  
   198  func (lkb lazyKeybase) ImportPubKey(name string, armor string) (err error) {
   199  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   200  	if err != nil {
   201  		return err
   202  	}
   203  	defer db.Close()
   204  
   205  	return newDBKeybase(db, lkb.options...).ImportPubKey(name, armor)
   206  }
   207  
   208  func (lkb lazyKeybase) Export(name string) (armor string, err error) {
   209  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   210  	if err != nil {
   211  		return "", err
   212  	}
   213  	defer db.Close()
   214  
   215  	return newDBKeybase(db, lkb.options...).Export(name)
   216  }
   217  
   218  func (lkb lazyKeybase) ExportPubKey(name string) (armor string, err error) {
   219  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   220  	if err != nil {
   221  		return "", err
   222  	}
   223  	defer db.Close()
   224  
   225  	return newDBKeybase(db, lkb.options...).ExportPubKey(name)
   226  }
   227  
   228  func (lkb lazyKeybase) ExportPrivateKeyObject(name string, passphrase string) (crypto.PrivKey, error) {
   229  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   230  	if err != nil {
   231  		return nil, err
   232  	}
   233  	defer db.Close()
   234  
   235  	return newDBKeybase(db, lkb.options...).ExportPrivateKeyObject(name, passphrase)
   236  }
   237  
   238  func (lkb lazyKeybase) ExportPrivKey(name string, decryptPassphrase string,
   239  	encryptPassphrase string) (armor string, err error) {
   240  
   241  	db, err := sdk.NewDB(lkb.name, lkb.dir)
   242  	if err != nil {
   243  		return "", err
   244  	}
   245  	defer db.Close()
   246  
   247  	return newDBKeybase(db, lkb.options...).ExportPrivKey(name, decryptPassphrase, encryptPassphrase)
   248  }
   249  
   250  // SupportedAlgos returns a list of supported signing algorithms.
   251  func (lkb lazyKeybase) SupportedAlgos() []SigningAlgo {
   252  	return newBaseKeybase(lkb.options...).SupportedAlgos()
   253  }
   254  
   255  // SupportedAlgosLedger returns a list of supported ledger signing algorithms.
   256  func (lkb lazyKeybase) SupportedAlgosLedger() []SigningAlgo {
   257  	return newBaseKeybase(lkb.options...).SupportedAlgosLedger()
   258  }
   259  
   260  func (lkb lazyKeybase) CloseDB() {}
   261  
   262  // FileDir show lazyKeybase position
   263  func (lkb lazyKeybase) FileDir() (string, error) {
   264  	return resolvePath(lkb.dir)
   265  }