// generateFund is the high-level logic for funding any P2SH address with the 'go-bitcoin-multisig fund' subcommand.
// Takes flagPrivateKey (private key of input Bitcoins to fund with), flagInputTx (input transaction hash of
// Bitcoins to fund with), flagAmount (amount in Satoshis to send, with balance left over from input being used
// as transaction fee) and flagP2SHDestination (destination P2SH multisig address which is being funded) as arguments.
func generateFund(flagPrivateKey string, flagInputTx string, flagAmount int, flagP2SHDestination string) string {
//Get private key as decoded raw bytes
privateKey := base58check.Decode(flagPrivateKey)
//In order to construct the raw transaction we need the input transaction hash,
//the P2SH destination address, the number of satoshis to send, and the scriptSig
//which is temporarily (prior to signing) the ScriptPubKey of the input transaction.
publicKey, err := btcutils.NewPublicKey(privateKey)
if err != nil {
log.Fatal(err)
}
publicKeyHash, err := btcutils.Hash160(publicKey)
if err != nil {
log.Fatal(err)
}
tempScriptSig, err := btcutils.NewP2PKHScriptPubKey(publicKeyHash)
if err != nil {
log.Fatal(err)
}
redeemScriptHash := base58check.Decode(flagP2SHDestination)
//Create our scriptPubKey
scriptPubKey, err := btcutils.NewP2SHScriptPubKey(redeemScriptHash)
if err != nil {
log.Fatal(err)
}
//Create unsigned raw transaction
rawTransaction, err := btcutils.NewRawTransaction(flagInputTx, flagAmount, tempScriptSig, scriptPubKey)
if err != nil {
log.Fatal(err)
}
//After completing the raw transaction, we append
//SIGHASH_ALL in little-endian format to the end of the raw transaction.
hashCodeType, err := hex.DecodeString("01000000")
if err != nil {
log.Fatal(err)
}
var rawTransactionBuffer bytes.Buffer
rawTransactionBuffer.Write(rawTransaction)
rawTransactionBuffer.Write(hashCodeType)
rawTransactionWithHashCodeType := rawTransactionBuffer.Bytes()
//Sign the raw transaction, and output it to the console.
finalTransaction, err := signP2PKHTransaction(rawTransactionWithHashCodeType, privateKey, scriptPubKey, flagInputTx, flagAmount)
if err != nil {
log.Fatal(err)
}
finalTransactionHex := hex.EncodeToString(finalTransaction)
return finalTransactionHex
}
// generateAddress is the high-level logic for creating P2SH multisig addresses with the 'go-bitcoin-multisig address' subcommand.
// Takes flagM (number of keys required to spend), flagN (total number of keys)
// and flagPublicKeys (comma separated list of N public keys) as arguments.
func generateAddress(flagM int, flagN int, flagPublicKeys string) (string, string) {
//Convert public keys argument into slice of public key bytes with necessary tidying
flagPublicKeys = strings.Replace(flagPublicKeys, "'", "\"", -1) //Replace single quotes with double since csv package only recognizes double quotes
publicKeyStrings, err := csv.NewReader(strings.NewReader(flagPublicKeys)).Read()
if err != nil {
log.Fatal(err)
}
publicKeys := make([][]byte, len(publicKeyStrings))
for i, publicKeyString := range publicKeyStrings {
publicKeyString = strings.TrimSpace(publicKeyString) //Trim whitespace
publicKeys[i], err = hex.DecodeString(publicKeyString) //Get private keys as slice of raw bytes
if err != nil {
log.Fatal(err, "\n", "Offending publicKey: \n", publicKeyString)
}
}
//Create redeemScript from public keys
redeemScript, err := btcutils.NewMOfNRedeemScript(flagM, flagN, publicKeys)
if err != nil {
log.Fatal(err)
}
redeemScriptHash, err := btcutils.Hash160(redeemScript)
if err != nil {
log.Fatal(err)
}
//Get P2SH address by base58 encoding with P2SH prefix 0x05
P2SHAddress := base58check.Encode("05", redeemScriptHash)
//Get redeemScript in Hex
redeemScriptHex := hex.EncodeToString(redeemScript)
return P2SHAddress, redeemScriptHex
}
// generateKeys is the high-level logic for generating public/private key pairs with the 'go-bitcoin-multisig keys' subcommand.
// Takes flagCount (desired number of key pairs) and flagConcise (true hides warnings and helpful messages for conciseness)
// as arguments.
func generateKeys(flagKeyCount int) ([]string, []string, []string) {
publicKeyHexs := make([]string, flagKeyCount)
publicAddresses := make([]string, flagKeyCount)
privateKeyWIFs := make([]string, flagKeyCount)
for i := 0; i <= flagKeyCount-1; i++ {
//Generate private key
privateKey := btcutils.NewPrivateKey()
//Generate public key from private key
publicKey, err := btcutils.NewPublicKey(privateKey)
if err != nil {
log.Fatal(err)
}
//Get hex encoded version of public key
publicKeyHexs[i] = hex.EncodeToString(publicKey)
//Get public address by hashing with SHA256 and RIPEMD160 and base58 encoding with mainnet prefix 00
publicKeyHash, err := btcutils.Hash160(publicKey)
if err != nil {
log.Fatal(err)
}
publicAddresses[i] = base58check.Encode("00", publicKeyHash)
//Get private key in Wallet Import Format (WIF) by base58 encoding with prefix 80
privateKeyWIFs[i] = base58check.Encode("80", privateKey)
}
return privateKeyWIFs, publicKeyHexs, publicAddresses
}
