Parse transaction details

[souvikhaldar]

Can someone provide resources/guides/etc on how to compute the sender, receiver, amount transferred and time of tx, preferably in golang.
I'm running a btcd node and using its client fetching the blocks.

[souvikhaldar]

Currently using this logic:-

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"time"

	"github.com/btcsuite/btcd/btcutil"
	"github.com/btcsuite/btcd/chaincfg"
	"github.com/btcsuite/btcd/rpcclient"
	"github.com/btcsuite/btcd/txscript"
)

func main() {
	
	// Connect to the Bitcoin Core RPC server
	connConfig := &rpcclient.ConnConfig{
		Host:         "localhost:8334", // Update with the correct RPC host and port for your Bitcoin Core configuration
		User:         "",
		Pass:         "",
		HTTPPostMode: true,
		DisableTLS:   true,
	}
	client, err := rpcclient.New(connConfig, nil)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Shutdown()

	// Get the current block height
	blockCount, err := client.GetBlockCount()
	if err != nil {
		log.Fatal(err)
	}

	// Iterate over each block
	for i := int64(blockCount - 1); ; i++ {
		
		// Get the block hash for the given block height
		blockHash, err := client.GetBlockHash(i)
		if err != nil {
			log.Fatal(err)
		}

		// Retrieve the block details
		block, err := client.GetBlock(blockHash)
		if err != nil {
			log.Fatal(err)
		}

		ts := block.Header.Timestamp

		// Iterate over each transaction in the block
		for _, tx := range block.Transactions {
			var t Tx

			t.Timestamp = ts
			h := tx.TxHash()
			txVerbose, err := client.GetRawTransactionVerbose(&h)
			if err != nil {
				log.Fatal(err)
			}
			totalAmount := float64(0)
			for _, output := range txVerbose.Vout {
				totalAmount += output.Value
			}
			t.Amount = totalAmount // TODO: convert satoshi to BTC

			// Iterate over each transaction input
			for j, vin := range tx.TxIn {
				if j == 0 {
					continue
				}
				// Retrieve the previous transaction output
				prevTx, err := client.GetRawTransactionVerbose(&vin.PreviousOutPoint.Hash)
				if err != nil {
					log.Println(err)
					continue
				}

				// Retrieve the sender's address from the scriptPubKey of the previous output

				senderAddress := prevTx.Vout[vin.PreviousOutPoint.Index].ScriptPubKey.Addresses[0]

				t.Sender = senderAddress
			}

			// Iterate over each transaction output
			for _, vout := range tx.TxOut {
				// Retrieve the receiver address from the transaction output
				receiverAddress, err := getAddressFromScriptPubKey(vout.PkScript, &chaincfg.MainNetParams)
				if err != nil {
					log.Println(err)
					continue
				}

				t.Receiver = receiverAddress.EncodeAddress()
			}

			// check if all values are present
			fmt.Printf("Details of the tx: %+v\n", t)
			if t.Sender != "" && t.Receiver != "" && (t.Timestamp == time.Time{} || t.Timestamp.String() == "0001-01-01 00:00:00 +0000 UTC") && t.Amount != float64(0) {
				fmt.Printf("%s sent %f BTC to %s at %s\n", t.Sender, t.Amount, t.Receiver, t.Timestamp)
				txs = append(txs, t)
				fmt.Println("--------------------------")

			}

		}
		

		// time to mine a new block
		time.Sleep(10 * time.Minute)
	}
}

func getAddressFromScriptPubKey(scriptPubKey []byte, params *chaincfg.Params) (btcutil.Address, error) {
	_, addresses, _, err := txscript.ExtractPkScriptAddrs(scriptPubKey, params)
	if err != nil {
		return nil, err
	}

	if len(addresses) == 0 {
		return nil, fmt.Errorf("no address found in script")
	}

	return addresses[0], nil
}

[guggero]

This looks pretty good. What are you missing? Or what are you trying to achieve that the above code doesn't do yet?

[souvikhaldar]

I'm not sure if the values are correct. Specifically the sender and amount. Can you confirm?

[guggero]

Yes, I think it looks good, at least from a quick glance. But you can always verify your output against one of the block explorers out there, like https://blockstream.info/ or https://mempool.space/