In case you missed it, here's a link to the video on YouTube.

What we wanted to do:

This week, we continued our intial exploration of UTXO RPC, which provides a shared specification for interacting with the Cardano blockchain.

Our goal was to see if we could implement a query tip function using the recently released a minimal implementation of the GetChainTip endpoint from Blink Labs.

Here is the code:

1func chainTip() {
2	ctx := context.Background()
3	httpClient := &http.Client{
4		// http client connection details
5	}
6    // we're using demeter to access the data
7	baseUrl := "https://preview.utxorpc-v0.demeter.run"
8	client := utxorpc.NewClient(httpClient, baseUrl)
9	req := connect.NewRequest(&sync.FetchBlockRequest{})
10    // and including an api key
11	apiKey := os.Getenv("DEMETER_API_KEY")
12	req.Header().Set("dmtr-api-key", apiKey)
13	fmt.Println("connecting to utxorpc host:", baseUrl)
14    // here's what UTxO RPC provides:
15	chainSync, err := client.ChainSync.FetchBlock(ctx, req)
16	// boilerplate error checking
17    if err != nil {
18		fmt.Println(connect.CodeOf(err))
19		if connectErr := new(connect.Error); errors.As(err, &connectErr) {
20			fmt.Println(connectErr.Message())
21			fmt.Println(connectErr.Details())
22		}
23		os.Exit(1)
24	}
25	fmt.Println("connected to utxorpc...")
26	// for now, simply print the results in the terminal
27    for i, blockRef := range chainSync.Msg.Block {
28		fmt.Printf("Block[%d]:\n", i)
29		fmt.Printf("Index: %d\n", blockRef.GetCardano().GetHeader().GetSlot())
30		fmt.Printf("Hash: %x\n", blockRef.GetCardano().GetHeader().GetHash())
31	}
32}

What we did:

We didn't quite get the function to work, but we learned firsthand how UTxO RPC ensures stability. Because the version of the Go Codegen did not match the current version of the UTxO RPC specification used at the Demeter endpoint, our endpoint would not work.

Instead, we got to take a look under the hood at how different UTxO RPC compliant endpoints are being built in cardano-node-api. We took a brief look at how gouroboros is being used, and we discussed the potential of other endpoints, like 'hold UTXOs,' which might have some interesting applications in transaction-chaining.

What we learned:

It's important to understand how versioning and compatiblity work across UTxO RPC. This week, the chainTip function didn't work, but in the long run, this is a really good thing. We only want to use these RPC functions if we have some assurance that they do what we think they do, that they're stable, and can't be changed. The current goal of everyone working on UTxO RPC is to reach a stable V1 version, so that developers can start to use it, and where breaking changes will require a new major version (V2).

What's Next?

When the endpoint is ready and versions are aligned, we will revisit the chainTip above.
In the meantime, we will focus on building transactions in other ways, as we continue our adventures...

About Cardano Go Live Coding

Cardano Go Live Coding meets on Mondays from 1300-1400 UTC.

Follow the project:

Notion page - public dashboard
Andamio CLI on GitHub

Register for Weekly Live Coding Sessions

Every Monday 1300-1400 UTC

If you’re just getting started

If you are a brand new to Go, check out the official tutorial. Then, take a look at Go by Example - it's a great introduction.
On YouTube: How to write beautiful Golang CLI is a helpful overview of Cobra CLI, and it illustrates the design patterns we're using with Andamio CLI
Cardano Go PBL is currently in development - we'll share more soon!

The team is working towards creating a PBL (Project-Based Learning) course, and the current focus is on generating raw materials, including code examples and lessons.

Cardano Go Live Coding Session #004