Anther v0.1.0: A Modern Go SDK for Building on Hive

Hey everyone,

The work to modernize Hive developer tooling is continuing.

Pollen gives JavaScript and TypeScript developers a modern path forward. You can read that announcement here and we have continued to work with it and on it.

Nectar covers Python, it started this whole journey.

And today we want to share that Anther v0.1.0 is officially available for Go developers.

Anther is a Go SDK for building Hive services, bots, indexers, transaction tools, and other applications that need to communicate with the blockchain without depending on an aging client stack.

It includes local transaction serialization and signing, node failover, encrypted memos, account helpers, social API methods, multi-key authority verification, and native block and operation streams built around goroutines and channels.

This is the first tagged release.

It is not the end of the work, but it is a real starting point developers can pin, test, and build against.

Why Go?

Go is a practical language for infrastructure.

It produces simple standalone binaries. Its concurrency model is easy to reason about. The standard library is strong, cross-compilation is straightforward, and long-running services do not need a complicated runtime environment.

That makes it a good fit for Hive applications such as:

• bots that need to stay online around the clock
• block and operation indexers
• account monitoring services
• transaction broadcasters
• notification and community tools
• backend APIs serving Hive data

Hive has plenty of JavaScript and Python history, but developers should not have to switch languages just to get a usable SDK.

Anther is meant to feel like a Go library.

It uses explicit errors, goroutines, channels, contexts, and small focused packages rather than trying to copy the shape of any SDK from another language.

Transactions Stay Local

The most important part of any blockchain SDK is what it does with transactions and private keys.

Anther serializes supported Hive operations locally.

It can construct a transaction, fetch the current TaPoS block parameters, encode the transaction into Hive-compatible bytes, sign those bytes with a WIF private key, calculate the transaction ID, and broadcast the signed result.

The private key does not need to be sent to an RPC node.

The serialization layer currently supports operations including:

• votes
• comments
• transfers
• custom JSON
• comment options
• account updates
• account claims
• claimed-account creation

Anther uses the Decred secp256k1 implementation for compact recoverable signatures and canonical low-S handling.

That does not remove the need for careful review and testing.

It does give the project an explicit, inspectable signing path built on a focused cryptographic dependency instead of a remote serialization call.

Reading Account Data

The current release is tagged as v0.1.0:

go get github.com/srbde/[email protected]

Anther provides both lower-level client methods and a higher-level account wrapper.

Here is a basic account lookup:

package main

import (
    "fmt"
    "log"

    "github.com/srbde/hive-anther/account"
    "github.com/srbde/hive-anther/client"
)

func main() {
    api := client.NewClient([]string{
        "https://api.hive.blog",
        "https://api.deathwing.me",
    }, 30)

    acct := account.NewAccount("thecrazygm", api)
    if err := acct.Refresh(); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Account: @%s\n", acct.Name)
    fmt.Printf("HIVE: %v\n", acct.Data["balance"])
    fmt.Printf("HBD: %v\n", acct.Data["hbd_balance"])
}

The account package also includes helpers for reputation, voting power, Resource Credits, following, unfollowing, ignoring, and unignoring accounts.

Anther can calculate HP from VESTS using current dynamic global properties rather than forcing every application to repeat that conversion itself.

These are small conveniences, but they are exactly the kind of repeated blockchain-specific work an SDK should own.

Signing and Broadcasting

A transfer follows the same direct pattern:

package main

import (
    "fmt"
    "log"
    "os"

    "github.com/srbde/hive-anther/client"
    "github.com/srbde/hive-anther/transaction"
)

func main() {
    api := client.NewClient([]string{
        "https://api.hive.blog",
        "https://api.deathwing.me",
    }, 30)

    tx := transaction.NewTransaction(api)
    tx.AppendOp(&transaction.Transfer{
        From:   "youraccount",
        To:     "recipient",
        Amount: "0.001 HIVE",
        Memo:   "Sent with Anther",
    })

    if err := tx.Sign(os.Getenv("ACTIVE_WIF")); err != nil {
        log.Fatal(err)
    }

    result, err := tx.Broadcast()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Broadcast result: %v\n", result)
}

The client retrieves the live block data needed for the transaction. The transaction package handles the wire format and signing. The node receives the completed signed transaction.

That separation is intentional.

Anther also supports signing with multiple keys and verifying that a transaction satisfies a supplied authority threshold.

Go-Native Blockchain Streams

One of Anther's strongest features is live blockchain streaming.

Go already has the right tools for this job.

Goroutines handle the ongoing work. Channels deliver blocks, operations, and errors. A context.Context gives the caller a clean way to stop the stream or enforce a deadline.

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

ops, errs := api.StreamOperations(
    ctx,
    0,
    client.Irreversible,
    []string{"transfer"},
)

for {
    select {
    case op := <-ops:
        fmt.Printf("Transfer in block %d: %v\n", op.Block, op.Op[1])
    case err := <-errs:
        if err != nil {
            log.Printf("stream error: %v", err)
        }
    case <-ctx.Done():
        return
    }
}

Anther can stream full blocks or filter applied and virtual operations by type.

That gives indexers and monitoring tools a useful foundation without making each project rebuild polling, block progression, cancellation, and error delivery from scratch.

Resilient RPC Access

Public RPC nodes fail.

From time to time they time out, rate-limit, return HTTP errors, reject specific API calls, or temporarily fall behind the chain.

A production client has to expect that.

Anther accepts a list of nodes and keeps track of the active connection. When a request fails, it can retry with exponential backoff and rotate to another endpoint. The failover behavior covers transport failures, unsuccessful HTTP responses, and JSON-RPC errors.

The client also stays on a working node instead of pointlessly rotating after every successful request.

That sounds like a small implementation detail but for a service that needs to run unattended, it is the difference between a temporary node problem and an application outage.

More Than Database Calls

Anther is not limited to basic condenser-style account queries.

The current API includes helpers for areas such as:

• dynamic global properties
• account history
• blocks and block ranges
• applied and virtual operations
• ranked posts and account posts
• communities
• account notifications
• unread notification counts
• content replies and discussions
• follow counts
• HAF-backed reputation and balance data

There is also an in-memory wallet for managing account keys and signing transactions, plus compatible private memo encryption and decryption.

Encrypted memos use secp256k1 shared-secret derivation, AES encryption, and the envelope format expected by the Hive ecosystem.

The goal is not to expose every possible method on day one.

The goal is to provide enough coherent pieces that developers can build complete Go applications without reaching for a second library every time they move beyond a basic RPC request.

Honest v0.1.0 Notes

Anther is a first tagged release.

The tag makes dependency management predictable, but v0.1.0 still means the public API can evolve before v1.0.

The current module declares Go 1.26.3. Use a compatible Go toolchain and pin the release explicitly in applications that need reproducible builds.

If you are evaluating Anther now:

• test the operations your application actually broadcasts
• start with small-value transactions
• configure more than one RPC endpoint
• keep WIF keys in a proper secret store
• use contexts to bound long-running work
• report missing methods and unexpected chain responses

The codebase has broad unit and integration-style coverage, but real applications will always find combinations a test suite did not anticipate.

That feedback is useful at this stage.

One Ecosystem, Several Languages

Anther is part of the same SRBDE developer-tooling effort as Pollen, and Nectar.

The projects share standards without pretending every language should expose an identical API.

Pollen follows modern TypeScript conventions.

Nectar remains natural for Python developers.

Anther uses the concurrency model and straightforward package structure Go developers expect.

Different languages.

The same priorities:

• local transaction signing
• explicit serialization
• resilient node access
• useful blockchain-specific helpers
• maintained dependencies
• tests around the dangerous parts

Hive becomes easier to build on when developers can choose the right language for the application instead of choosing whichever language happens to have a surviving SDK.

Where It Stands Now

Anther v0.1.0 is available through the Go module system:

go get github.com/srbde/[email protected]

The source and release are available at:

https://github.com/srbde/hive-anther

https://github.com/srbde/hive-anther/releases/tag/v0.1.0

If you build Hive software in Go, I would like to hear what you need from it.

Try the account helpers.

Run a block stream.

Test node failover.

Review the transaction bytes.

Build a small bot or service and report where the API feels awkward or incomplete.

That is how a first release becomes dependable infrastructure.

Closing Thoughts

An anther is the part of a flower that produces pollen.

That made the name a natural fit beside Pollen.

The names are connected because the projects are connected: separate tools doing different jobs while supporting the same ecosystem.

Anther v0.1.0 gives Go developers a modern foundation for interacting with Hive, signing transactions locally, and building services that can survive more than one unreliable RPC endpoint.

It is early, and it is tagged.

And! It is now ready for Go developers to start putting it through its paces - putting it to work!

As always,
Michael Garcia a.k.a. TheCrazyGM