// newManagedAddress returns a new managed address based on the passed account,
// private key, and whether or not the public key is compressed. The managed
// address will have access to the private and public keys.
func newManagedAddress(m *Manager, account uint32,
privKey chainec.PrivateKey) (*managedAddress, error) {
if privKey == nil {
err := fmt.Errorf("missing private key")
return nil, managerError(ErrNoExist, "nil pointer", err)
}
// Encrypt the private key.
//
// NOTE: The privKeyBytes here are set into the managed address which
// are cleared when locked, so they aren't cleared here.
privKeyBytes := privKey.Serialize()
privKeyEncrypted, err := m.cryptoKeyPriv.Encrypt(privKeyBytes)
if err != nil {
str := "failed to encrypt private key"
return nil, managerError(ErrCrypto, str, err)
}
// Leverage the code to create a managed address without a private key
// and then add the private key to it.
pubx, puby := privKey.Public()
ecPubKey := chainec.Secp256k1.NewPublicKey(pubx, puby)
managedAddr, err := newManagedAddressWithoutPrivKey(m, account,
ecPubKey, true)
if err != nil {
return nil, err
}
managedAddr.privKeyEncrypted = privKeyEncrypted
managedAddr.privKeyCT = privKeyBytes
return managedAddr, nil
}
// SignatureScript creates an input signature script for tx to spend coins sent
// from a previous output to the owner of privKey. tx must include all
// transaction inputs and outputs, however txin scripts are allowed to be filled
// or empty. The returned script is calculated to be used as the idx'th txin
// sigscript for tx. subscript is the PkScript of the previous output being used
// as the idx'th input. privKey is serialized in either a compressed or
// uncompressed format based on compress. This format must match the same format
// used to generate the payment address, or the script validation will fail.
func SignatureScript(tx *wire.MsgTx, idx int, subscript []byte,
hashType SigHashType, privKey chainec.PrivateKey, compress bool) ([]byte,
error) {
sig, err := RawTxInSignature(tx, idx, subscript, hashType, privKey)
if err != nil {
return nil, err
}
pubx, puby := privKey.Public()
pub := chainec.Secp256k1.NewPublicKey(pubx, puby)
var pkData []byte
if compress {
pkData = pub.SerializeCompressed()
} else {
pkData = pub.SerializeUncompressed()
}
return NewScriptBuilder().AddData(sig).AddData(pkData).Script()
}
// SignatureScriptAlt creates an input signature script for tx to spend coins sent
// from a previous output to the owner of privKey. tx must include all
// transaction inputs and outputs, however txin scripts are allowed to be filled
// or empty. The returned script is calculated to be used as the idx'th txin
// sigscript for tx. subscript is the PkScript of the previous output being used
// as the idx'th input. privKey is serialized in the respective format for the
// ECDSA type. This format must match the same format used to generate the payment
// address, or the script validation will fail.
func SignatureScriptAlt(tx *wire.MsgTx, idx int, subscript []byte,
hashType SigHashType, privKey chainec.PrivateKey, compress bool,
sigType int) ([]byte,
error) {
sig, err := RawTxInSignatureAlt(tx, idx, subscript, hashType, privKey,
sigTypes(sigType))
if err != nil {
return nil, err
}
pubx, puby := privKey.Public()
var pub chainec.PublicKey
switch sigTypes(sigType) {
case edwards:
pub = chainec.Edwards.NewPublicKey(pubx, puby)
case secSchnorr:
pub = chainec.SecSchnorr.NewPublicKey(pubx, puby)
}
pkData := pub.Serialize()
return NewScriptBuilder().AddData(sig).AddData(pkData).Script()
}