in

¿Hay alguna solución testnet3 Bitcoin viable para crear, firmar y transmitir una transacción normal usando Golang?

Actualmente estoy tratando de crear, firmar y transmitir transacciones de bitcoin usando btcsuite. Para empezar, ya tenía la dirección testnet3 y su clave privada asociada para la prueba. Sin embargo, buscando a través de la publicación y artículos como a continuación:

  1. aquí
  2. aquí
  3. aquí

La solución propuesta anteriormente no está completa, para la primera, solo cubre hasta la firma (sabía que el autor afirmó que no se puede transmitir a menos que proporcione el utxo, lo cual hice si tengo razón), pero cuando intenté transmitir falló con el mensaje

«Error al validar la transacción: transacción be9b294695bfb201a5cff32af074a4bf72b073e3c9dad1969111165bf118a622 huérfana, falta la referencia f0c0d3b3eecf911ede996a74ceadc9366068791450c9e6bacee96ae2001f3».

No tengo idea de lo que está pasando y sospecho que su guión es incompatible.

Entonces, la conclusión es que solo quiero un ejemplo viable en bitcoin testnet3 que muestre «desde 1 dirección, transfiera algunos bitcoins a otra dirección» mostrando el proceso de creación de una transacción sin procesar, fírmela con clave privada, conviértala en una transacción sin procesar en hexadecimal. formatee y transmita usando algo como https://live.blockcypher.com/btc/pushtx/ (BTC testnet)

actualmente mi código es el siguiente: –

package main
import (
    "fmt"
    "encoding/hex"
    "bytes"
    "github.com/btcsuite/btcutil"
    btcchain "github.com/btcsuite/btcd/chaincfg"
    "github.com/btcsuite/btcd/chaincfg/chainhash"
    "github.com/btcsuite/btcd/txscript"
    "github.com/btcsuite/btcd/wire"
)
func txToHex(tx *wire.MsgTx) string {
    buf := bytes.NewBuffer(make([]byte, 0, tx.SerializeSize()))
    tx.Serialize(buf)
    return hex.EncodeToString(buf.Bytes())
}

func stkbtc(){
  pvkey := "cNjXNxcfawzyfGUxaG94rKqayAL2n7QWioKhCkHbQsBRT7SbDyGu"
  txHash := "e028b5bf030a24986a03b03b89dec037e8462ae32bc93679cb49d7c779685987"
  destination := "n2kRiAkW1xr5DVy7QKVGaYiZbwpS7j23jJ"
  var amount int64 = 100000000
  txFee := int64(500000)

  //try send btc
  decodedwif,err := btcutil.DecodeWIF(pvkey)
  if err != nil {
    fmt.Printf("decodedwif error: %v\n",err)
  }
  fmt.Printf("decodedwif       : %v\n",decodedwif)

  addresspubkey, _ := btcutil.NewAddressPubKey(decodedwif.PrivKey.PubKey().SerializeUncompressed(), &btcchain.TestNet3Params)
  sourceTx := wire.NewMsgTx(wire.TxVersion)
  sourceUtxoHash, _ := chainhash.NewHashFromStr(txHash)

  sourceUtxo := wire.NewOutPoint(sourceUtxoHash, 0)

  sourceTxIn := wire.NewTxIn(sourceUtxo, nil, nil)
  destinationAddress, _ := btcutil.DecodeAddress(destination, &btcchain.TestNet3Params)

  sourceAddress, err := btcutil.DecodeAddress(addresspubkey.EncodeAddress(), &btcchain.TestNet3Params)
  if err != nil {
    fmt.Printf("sourceAddress err: %v\n",err)
  }

  destinationPkScript, _ := txscript.PayToAddrScript(destinationAddress)

  sourcePkScript, _ := txscript.PayToAddrScript(sourceAddress)
  sourceTxOut := wire.NewTxOut(amount, sourcePkScript)

  sourceTx.AddTxIn(sourceTxIn)
  sourceTx.AddTxOut(sourceTxOut)
  sourceTxHash := sourceTx.TxHash()

  redeemTx := wire.NewMsgTx(wire.TxVersion)
  prevOut := wire.NewOutPoint(&sourceTxHash, 0)
  redeemTxIn := wire.NewTxIn(prevOut, nil, nil)
  redeemTx.AddTxIn(redeemTxIn)
  redeemTxOut := wire.NewTxOut((amount - txFee), destinationPkScript)
  redeemTx.AddTxOut(redeemTxOut)

  sigScript, err := txscript.SignatureScript(redeemTx, 0, sourceTx.TxOut[0].PkScript, txscript.SigHashAll, decodedwif.PrivKey, false)
  if err != nil {
    fmt.Printf("sigScript err: %v\n",err)
  }
  redeemTx.TxIn[0].SignatureScript = sigScript
  fmt.Printf("sigScript: %v\n",hex.EncodeToString(sigScript))


  //Validate signature
  flags := txscript.StandardVerifyFlags
  vm, err := txscript.NewEngine(sourceTx.TxOut[0].PkScript, redeemTx, 0, flags, nil, nil, amount)
  if err != nil {
    fmt.Printf("err != nil: %v\n",err)
  }
  if err := vm.Execute(); err != nil {
    fmt.Printf("vm.Execute > err != nil: %v\n",err)
  }

  fmt.Printf("redeemTx: %v\n",txToHex(redeemTx))
}

func main(){
    stkbtc()
}

el txhash fue de una transacción anterior donde obtuve el testnet bitcoin de faucet y nada más.

  • Dirección del remitente: mpYGA8wRCArpGTs6aJMmZRWyUuPoZmeLJv
  • Clave pública del remitente: 02217deb8b3782236fa8214da94bd5a9338f2eeb3299c39c057fb68ada63d93df7
  • Clave privada del remitente: cNjXNxcfawzyfGUxaG94rKqayAL2n7QWioKhCkHbQsBRT7SbDyGu

  • Dirección de destino: n2kRiAkW1xr5DVy7QKVGaYiZbwpS7j23jJ

Por favor, aconseje qué está mal con el código anterior, realmente lo agradecería si alguien puede señalarlo.

2 respuestas
2

Supongo que encontré el problema: el código generó una transacción falsa que creó el UTXO y hacía referencia a su TXID en lugar del TXID de la transacción real.

Hola, tengo la experiencia de escribir código golang interactivo con bitcoin, si desea crear la transacción y firmarla, es realmente complicado, le sugiero que use bitcoind rpc para hacerlo. Aquí hay un envoltorio golang rpc viable (para testnet3 y mainnet también) https://github.com/huahuayu/go-bitcoind, lo uso en mi proyecto, si tiene alguna pregunta, deje un mensaje.

¿Te ayudó la respuesta?

Subscribirse
Notificar por
guest
0 Comentarios
Inline Feedbacks
Ver todas las Respuestas

¿Es posible guardar de forma masiva todos los diagramas en PNG usando draw.io? [closed]

Independencia condicional en el algoritmo EM