// TestFilterInsertKey ensures inserting public keys and addresses works as // expected. func TestFilterInsertKey(t *testing.T) { secret := "5Kg1gnAjaLfKiwhhPpGS3QfRg2m6awQvaj98JCZBZQ5SuS2F15C" wif, err := btcutil.DecodeWIF(secret) if err != nil { t.Errorf("TestFilterInsertKey DecodeWIF failed: %v", err) return } f := bloom.NewFilter(2, 0, 0.001, wire.BloomUpdateAll) f.Add(wif.SerializePubKey()) f.Add(btcutil.Hash160(wif.SerializePubKey())) want, err := hex.DecodeString("038fc16b080000000000000001") if err != nil { t.Errorf("TestFilterInsertWithTweak DecodeString failed: %v\n", err) return } got := bytes.NewBuffer(nil) err = f.MsgFilterLoad().BtcEncode(got, wire.ProtocolVersion) if err != nil { t.Errorf("TestFilterInsertWithTweak BtcDecode failed: %v\n", err) return } if !bytes.Equal(got.Bytes(), want) { t.Errorf("TestFilterInsertWithTweak failure: got %v want %v\n", got.Bytes(), want) return } }
func (s *walletServer) ImportPrivateKey(ctx context.Context, req *pb.ImportPrivateKeyRequest) ( *pb.ImportPrivateKeyResponse, error) { defer zero.Bytes(req.Passphrase) wif, err := btcutil.DecodeWIF(req.PrivateKeyWif) if err != nil { return nil, grpc.Errorf(codes.InvalidArgument, "Invalid WIF-encoded private key: %v", err) } lock := make(chan time.Time, 1) defer func() { lock <- time.Time{} // send matters, not the value }() err = s.wallet.Unlock(req.Passphrase, lock) if err != nil { return nil, translateError(err) } // At the moment, only the special-cased import account can be used to // import keys. if req.Account != waddrmgr.ImportedAddrAccount { return nil, grpc.Errorf(codes.InvalidArgument, "Only the imported account accepts private key imports") } _, err = s.wallet.ImportPrivateKey(wif, nil, req.Rescan) if err != nil { return nil, translateError(err) } return &pb.ImportPrivateKeyResponse{}, nil }
func RedirectRequest(w http.ResponseWriter, r *http.Request) { key := r.URL.Path[36:] wif, err := btcutil.DecodeWIF(key) if err != nil { w.WriteHeader(http.StatusNotFound) return } page, _ := new(big.Int).DivMod(new(big.Int).SetBytes(wif.PrivKey.D.Bytes()), big.NewInt(ResultsPerPage), big.NewInt(ResultsPerPage)) page.Add(page, one) fragment, _ := btcutil.NewWIF(wif.PrivKey, &btcnet.MainNetParams, false) http.Redirect(w, r, "/"+page.String()+"#"+fragment.String(), http.StatusTemporaryRedirect) }
// signRawTransaction requires a transaction, a private key, and the bytes of the raw // scriptPubKey. It will then generate a signature over all of the outputs of // the provided tx. This is the last step of creating a valid transaction. func signRawTx(tx *Transaction, index int, wifPrivKey string, scriptPubKey []byte) ([]byte, error) { wif, err := btcutil.DecodeWIF(wifPrivKey) if err != nil { return []byte{}, err } // The all important signature. Each input is documented below. scriptSig, err := txscript.SignatureScript( &tx.MsgTx, // The tx to be signed. index, // The index of the txin the signature is for. scriptPubKey, // The other half of the script from the PubKeyHash. txscript.SigHashAll, // The signature flags that indicate what the sig covers. wif.PrivKey, // The key to generate the signature with. true, // The compress sig flag. This saves space on the blockchain. ) if err != nil { return []byte{}, err } return scriptSig, nil }