// New returns a new fully initialized instance of BtcWallet given a valid // configuration struct. func New(cfg *Config) (*BtcWallet, error) { // Ensure the wallet exists or create it when the create flag is set. netDir := networkDir(cfg.DataDir, cfg.NetParams) var pubPass []byte if cfg.PublicPass == nil { pubPass = defaultPubPassphrase } else { pubPass = cfg.PublicPass } loader := base.NewLoader(cfg.NetParams, netDir) walletExists, err := loader.WalletExists() if err != nil { return nil, err } var wallet *base.Wallet if !walletExists { // Wallet has never been created, perform initial set up. wallet, err = loader.CreateNewWallet(pubPass, cfg.PrivatePass, cfg.HdSeed) if err != nil { return nil, err } } else { // Wallet has been created and been initialized at this point, open it // along with all the required DB namepsaces, and the DB itself. wallet, err = loader.OpenExistingWallet(pubPass, false) if err != nil { return nil, err } } if err := wallet.Manager.Unlock(cfg.PrivatePass); err != nil { return nil, err } // Create a special websockets rpc client for btcd which will be used // by the wallet for notifications, calls, etc. rpcc, err := chain.NewRPCClient(cfg.NetParams, cfg.RpcHost, cfg.RpcUser, cfg.RpcPass, cfg.CACert, false, 20) if err != nil { return nil, err } db := wallet.Database() walletNamespace, err := db.Namespace(lnNamespace) if err != nil { return nil, err } return &BtcWallet{ wallet: wallet, rpc: rpcc, lnNamespace: walletNamespace, netParams: cfg.NetParams, utxoCache: make(map[wire.OutPoint]*wire.TxOut), }, nil }
// startChainRPC opens a RPC client connection to a btcd server for blockchain // services. This function uses the RPC options from the global config and // there is no recovery in case the server is not available or if there is an // authentication error. Instead, all requests to the client will simply error. func startChainRPC(certs []byte) (*chain.RPCClient, error) { log.Infof("Attempting RPC client connection to %v", cfg.RPCConnect) rpcc, err := chain.NewRPCClient(activeNet.Params, cfg.RPCConnect, cfg.BtcdUsername, cfg.BtcdPassword, certs, cfg.DisableClientTLS, 0) if err != nil { return nil, err } err = rpcc.Start() return rpcc, err }
func (s *loaderServer) StartConsensusRpc(ctx context.Context, req *pb.StartConsensusRpcRequest) ( *pb.StartConsensusRpcResponse, error) { defer zero.Bytes(req.Password) defer s.mu.Unlock() s.mu.Lock() if s.rpcClient != nil { return nil, grpc.Errorf(codes.FailedPrecondition, "RPC client already created") } networkAddress, err := cfgutil.NormalizeAddress(req.NetworkAddress, s.activeNet.RPCClientPort) if err != nil { return nil, grpc.Errorf(codes.InvalidArgument, "Network address is ill-formed: %v", err) } // Error if the wallet is already syncing with the network. wallet, walletLoaded := s.loader.LoadedWallet() if walletLoaded && wallet.SynchronizingToNetwork() { return nil, grpc.Errorf(codes.FailedPrecondition, "wallet is loaded and already synchronizing") } rpcClient, err := chain.NewRPCClient(s.activeNet.Params, networkAddress, req.Username, string(req.Password), req.Certificate, len(req.Certificate) == 0, 1) if err != nil { return nil, translateError(err) } err = rpcClient.Start() if err != nil { if err == btcrpcclient.ErrInvalidAuth { return nil, grpc.Errorf(codes.InvalidArgument, "Invalid RPC credentials: %v", err) } return nil, grpc.Errorf(codes.NotFound, "Connection to RPC server failed: %v", err) } s.rpcClient = rpcClient if walletLoaded { wallet.SynchronizeRPC(rpcClient) } return &pb.StartConsensusRpcResponse{}, nil }