Merge pull request #380 from blinklabs-io/feat/tx-submission-test-program

feat: finish tx-submission test program

Author: agaffney

cbor/encode.go

@@ -65,3 +65,27 @@ func EncodeGeneric(src interface{}) ([]byte, error) {
 	}
 	return cborData, nil
 }
+
+type IndefLengthList struct {
+	Items []any
+}
+
+func (i *IndefLengthList) MarshalCBOR() ([]byte, error) {
+	ret := []byte{
+		// Start indefinite-length list
+		0x9f,
+	}
+	for _, item := range i.Items {
+		data, err := Encode(&item)
+		if err != nil {
+			return nil, err
+		}
+		ret = append(ret, data...)
+	}
+	ret = append(
+		ret,
+		// End indefinite length array
+		byte(0xff),
+	)
+	return ret, nil
+}

cmd/tx-submission/main.go

@@ -15,23 +15,39 @@
 package main
 
 import (
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"os"
+	"time"
 
 	ouroboros "github.com/blinklabs-io/gouroboros"
+	"github.com/blinklabs-io/gouroboros/cbor"
 	"github.com/blinklabs-io/gouroboros/cmd/common"
 	"github.com/blinklabs-io/gouroboros/protocol/txsubmission"
+
+	"golang.org/x/crypto/blake2b"
 )
 
 type txSubmissionFlags struct {
 	*common.GlobalFlags
+	txFile    string
+	rawTxFile string
 }
 
+var txBytes []byte
+var txHash [32]byte
+var sentTx bool
+var doneChan chan any
+
 func main() {
 	// Parse commandline
 	f := txSubmissionFlags{
 		GlobalFlags: common.NewGlobalFlags(),
 	}
+	f.Flagset.StringVar(&f.txFile, "tx-file", "", "path to the JSON transaction file to submit")
+	f.Flagset.StringVar(&f.rawTxFile, "raw-tx-file", "", "path to the raw transaction file to submit")
 	f.Parse()
 	// Create connection
 	conn := common.CreateClientConnection(f.GlobalFlags)
@@ -51,18 +67,8 @@ func main() {
 		ouroboros.WithKeepAlive(true),
 		ouroboros.WithTxSubmissionConfig(
 			txsubmission.NewConfig(
-				txsubmission.WithRequestTxIdsFunc(
-					// TODO: do something more useful
-					func(blocking bool, ack uint16, req uint16) ([]txsubmission.TxIdAndSize, error) {
-						return []txsubmission.TxIdAndSize{}, nil
-					},
-				),
-				txsubmission.WithRequestTxsFunc(
-					// TODO: do something more useful
-					func(txIds []txsubmission.TxId) ([]txsubmission.TxBody, error) {
-						return []txsubmission.TxBody{}, nil
-					},
-				),
+				txsubmission.WithRequestTxIdsFunc(handleRequestTxIds),
+				txsubmission.WithRequestTxsFunc(handleRequestTxs),
 			),
 		),
 	)
@@ -71,9 +77,93 @@ func main() {
 		os.Exit(1)
 	}
 
+	// Read the transaction file
+	if f.txFile != "" {
+		txData, err := ioutil.ReadFile(f.txFile)
+		if err != nil {
+			fmt.Printf("Failed to load transaction file: %s\n", err)
+			os.Exit(1)
+		}
+
+		var jsonData map[string]string
+		err = json.Unmarshal(txData, &jsonData)
+		if err != nil {
+			fmt.Printf("failed to parse transaction file: %s\n", err)
+			os.Exit(1)
+		}
+
+		txBytes, err = hex.DecodeString(jsonData["cborHex"])
+		if err != nil {
+			fmt.Printf("failed to decode transaction: %s\n", err)
+			os.Exit(1)
+		}
+	} else if f.rawTxFile != "" {
+		txBytes, err = ioutil.ReadFile(f.rawTxFile)
+		if err != nil {
+			fmt.Printf("Failed to load transaction file: %s\n", err)
+			os.Exit(1)
+		}
+	} else {
+		fmt.Printf("You must specify one of -tx-file or -raw-tx-file\n")
+		os.Exit(1)
+	}
+
+	// Generate TX hash
+	// Unwrap raw transaction bytes into a CBOR array
+	var txUnwrap []cbor.RawMessage
+	if _, err := cbor.Decode(txBytes, &txUnwrap); err != nil {
+		fmt.Printf("ERROR: failed to unwrap transaction CBOR: %s", err)
+		os.Exit(1)
+	}
+	// index 0 is the transaction body
+	// Store index 0 (transaction body) as byte array
+	txBody := txUnwrap[0]
+
+	// Convert the body into a blake2b256 hash string
+	txHash = blake2b.Sum256(txBody)
+
+	// Create our "done" channel
+	doneChan = make(chan any)
+
 	// Start the TxSubmission activity loop
 	o.TxSubmission().Client.Init()
 
-	// Wait forever
-	select {}
+	// Wait until we're done
+	<-doneChan
+
+	fmt.Printf("Successfully sent transaction %x\n", txHash)
+
+	if err := o.Close(); err != nil {
+		fmt.Printf("ERROR: failed to close connection: %s\n", err)
+		os.Exit(1)
+	}
+}
+
+func handleRequestTxIds(blocking bool, ack uint16, req uint16) ([]txsubmission.TxIdAndSize, error) {
+	if sentTx {
+		// Terrible syncronization hack for shutdown
+		close(doneChan)
+		time.Sleep(5 * time.Second)
+	}
+	ret := []txsubmission.TxIdAndSize{
+		{
+			TxId: txsubmission.TxId{
+				EraId: 5,
+				TxId:  txHash,
+			},
+			Size: uint32(len(txBytes)),
+		},
+	}
+	return ret, nil
+}
+
+func handleRequestTxs(txIds []txsubmission.TxId) ([]txsubmission.TxBody, error) {
+	ret := []txsubmission.TxBody{
+		{
+			EraId:  5,
+			TxBody: txBytes,
+		},
+	}
+	sentTx = true
+	return ret, nil
 }

protocol/txsubmission/messages.go

@@ -80,6 +80,20 @@ type MsgReplyTxIds struct {
 	TxIds []TxIdAndSize
 }
 
+func (m *MsgReplyTxIds) MarshalCBOR() ([]byte, error) {
+	items := []any{}
+	for _, txId := range m.TxIds {
+		items = append(items, txId)
+	}
+	tmp := []any{
+		MessageTypeReplyTxIds,
+		cbor.IndefLengthList{
+			Items: items,
+		},
+	}
+	return cbor.Encode(tmp)
+}
+
 func NewMsgReplyTxIds(txIds []TxIdAndSize) *MsgReplyTxIds {
 	m := &MsgReplyTxIds{
 		MessageBase: protocol.MessageBase{
@@ -110,6 +124,20 @@ type MsgReplyTxs struct {
 	Txs []TxBody
 }
 
+func (m *MsgReplyTxs) MarshalCBOR() ([]byte, error) {
+	items := []any{}
+	for _, tx := range m.Txs {
+		items = append(items, tx)
+	}
+	tmp := []any{
+		MessageTypeReplyTxs,
+		cbor.IndefLengthList{
+			Items: items,
+		},
+	}
+	return cbor.Encode(tmp)
+}
+
 func NewMsgReplyTxs(txs []TxBody) *MsgReplyTxs {
 	m := &MsgReplyTxs{
 		MessageBase: protocol.MessageBase{
@@ -147,16 +175,31 @@ func NewMsgInit() *MsgInit {
 }
 
 type TxId struct {
+	cbor.StructAsArray
 	EraId uint16
 	TxId  [32]byte
 }
 
 type TxBody struct {
+	cbor.StructAsArray
 	EraId  uint16
 	TxBody []byte
 }
 
+func (t *TxBody) MarshalCBOR() ([]byte, error) {
+	tmp := []any{
+		t.EraId,
+		cbor.Tag{
+			// Wrapped CBOR
+			Number:  24,
+			Content: t.TxBody,
+		},
+	}
+	return cbor.Encode(&tmp)
+}
+
 type TxIdAndSize struct {
+	cbor.StructAsArray
 	TxId TxId
 	Size uint32
 }