main.go

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/blockcypher/gobcy"
	// "github.com/davecgh/go-spew/spew"
)

const (
	address          string = "1FoxBitjXcBeZUS4eDzPZ7b124q3N7QJK7"
	localEndpoint    string = "https://gist.githubusercontent.com/cesardeazevedo/f0d3de9f09c9d4293695f37679d19bc8/raw/8a4c09059cd84a9905c0f7e84db77afaa2926feb/blockcypher.json"
	firstBlockHeight string = "389416"
)

type App struct {
	gobcy                           gobcy.API
	token, address, lastBlockHeight string
	lastHeight                      int
	sheet                           *Sheet
}

func (a *App) fetchBlockHeight() int {
	chain, err := a.gobcy.GetChain()

	if err != nil {
		fmt.Println(err)
	}

	return chain.Height
}

func (a *App) fetchLocal() (address []gobcy.TX) {
	var target gobcy.Addr

	res, err := http.Get(localEndpoint)

	if err != nil {
		fmt.Print(err)
	}

	defer res.Body.Close()

	json.NewDecoder(res.Body).Decode(&target)

	return target.TXs
}

func (a *App) fetchBlockcypher() (transactions []gobcy.TX) {

	var txs []gobcy.TX
	before := a.lastHeight

	for i := 0; i < 180; i++ {

		fmt.Printf("Page Height: %v", before)

		addr, err := a.gobcy.GetAddrFull(address, map[string]string{
			"limit":  "50",
			"before": strconv.Itoa(before),
			// "confirmations": "1",
		})

		if err != nil {
			fmt.Println(err)
			break
		}

		currentLength := len(addr.TXs)

		if currentLength == 1 {
			fmt.Println("\nNo more transactions")
			break
		}

		for j := 0; j < len(addr.TXs); j++ {
			if addr.TXs[j].BlockHeight != -1 {
				txs = append(txs, addr.TXs[j])
			}
		}

		before = addr.TXs[len(addr.TXs)-1].BlockHeight

		fmt.Printf(" - length: %v\n", len(txs))

		time.Sleep(500 * time.Millisecond)
	}

	return txs
}

func (a *App) saveTXsToSpreadSheet(txs []gobcy.TX) {
	for i := 0; i < len(txs); i++ {
		a.sheet.AddRow(i, map[int]string{
			0: strconv.Itoa(txs[i].BlockHeight),
			1: txs[i].Hash,
			2: strconv.Itoa(txs[i].Fees),
		})
	}
}

func (a *App) parseFile() {
	f, err := ioutil.ReadFile("transactions.txt")

	if err != nil {
		panic(err.Error)
	}

	txs := strings.Split(string(f), "\n")

	for i := 0; i < len(txs); i++ {
		tx := strings.Split(txs[i], " ")
		a.sheet.AddRow(i, map[int]string{
			0: tx[1],
			1: tx[3],
			2: tx[5],
		})

		time.Sleep(500 * time.Millisecond)
	}
}

func writeTXsOnFile(txs []gobcy.TX) {
	f, err := os.Create("transactions.txt")
	if err != nil {
		panic(err.Error)
	}

	defer f.Close()

	for i := 0; i < len(txs); i++ {
		message := fmt.Sprintf("height: %v hash: %v fee: %v\n", txs[i].BlockHeight, txs[i].Hash, txs[i].Fees)
		_, err := f.WriteString(message)
		if err != nil {
			panic(err.Error)
		}
	}
}

func calculateFees(txs []gobcy.TX) (cum int) {
	cum = 0

	for i := 0; i < len(txs); i++ {
		cum = cum + txs[i].Fees
	}

	fmt.Printf("Fees: %d", cum)
	return
}

// Initialize struct app
func Initialize() *App {
	bcy := gobcy.API{"BLOCKCYPHER_HEY", "btc", "main"}
	app := &App{
		sheet: Auth("GOOGLE_SPREADSHEET_KEY"),
		gobcy: bcy,
	}

	app.lastHeight = app.fetchBlockHeight()

	return app
}

func main() {
	app := Initialize()
	app.parseFile()
	// txs := app.fetchBlockcypher()
	// writeTXsOnFile(txs)
	// txs := app.fetchLocal()
	// calculateFees(txs)
	// app.saveTXsToSpreadSheet(txs)
}

spreadsheet.go

package main

import (
	"fmt"
	"golang.org/x/net/context"
	"golang.org/x/oauth2/google"
	"gopkg.in/Iwark/spreadsheet.v2"
	"io/ioutil"
	"net/http"
)

// Sheet data
type Sheet struct {
	Client      *http.Client
	Service     *spreadsheet.Service
	Sheet       *spreadsheet.Sheet
	SpreadSheet spreadsheet.Spreadsheet
}

// Auth google cloud
func Auth(spreadSheetID string) *Sheet {
	data, err := ioutil.ReadFile("client_secret.json")
	checkError(err)

	conf, err := google.JWTConfigFromJSON(data, spreadsheet.Scope)
	checkError(err)

	client := conf.Client(context.TODO())
	service := spreadsheet.NewServiceWithClient(client)

	sheet := &Sheet{
		Client:  client,
		Service: service,
	}

	sheet.FetchSpreadsheet(spreadSheetID)
	sheet.GetSheet()

	return sheet
}

// FetchSpreadsheet Select a spreadsheet id
func (s *Sheet) FetchSpreadsheet(spreadSheetID string) (sheet spreadsheet.Spreadsheet) {
	spreadsheet, err := s.Service.FetchSpreadsheet(spreadSheetID)
	checkError(err)

	s.SpreadSheet = spreadsheet

	return
}

// GetSheet get a spreadsheet by index
func (s *Sheet) GetSheet() {
	sheet, err := s.SpreadSheet.SheetByIndex(0)
	checkError(err)

	s.Sheet = sheet

	return
}

// GetRow from a spreadsheet
func (s *Sheet) GetRow(row, column int) string {
	return s.Sheet.Rows[row][column].Value
}

// AddRow to a spreadsheet
func (s *Sheet) AddRow(row int, params map[int]string) {
	for k, v := range params {
		s.Sheet.Update(row, k, v)
	}

	s.Synchronize()
}

// Synchronize spreadsheet
func (s *Sheet) Synchronize() {
	if err := s.Sheet.Synchronize(); err != nil {
		panic(err.Error())
	}
}

func checkError(err error) {
	if err != nil {
		fmt.Println(err)
		panic(err.Error())
	}
}