---

BananoGo

Banano blockchain interaction library.

---

Features:

• Beginner-friendly functions (Send, Receive, ReceiveAll, ChangeRepresentative).
• Create, sign and process blocks.
• Send useful RPC requests.
• Send custom RPC requests.
• Unit conversion functions.
• Seed, Private Key, Public Key and Address conversion functions.
• Address validation.

You need another feature? Open an issue with the feature request label.

---

Installation

Use go get to install the package.

go get github.com/zenitria/bannanogo@latest

Example usage

package main

import (
    "fmt"
    "github.com/zenitria/bananogo"
)

func main() {
    // Create a new client
    client := bananogo.Client{
        Url: "http://localhost:7076",
    }

    // Send Banano
    address := "ban_14kwyg4wxw89orxsxgzgrf14exwa683rmubth4i6uh1dnoir1kb48ip4zwdt"
    seed := "D2F1A4C8E7B0E3D5F2A1C8E0B7D3F8A0B2C4E5D7F9C2A3B6D9F3C0A1B2E5D4"
    raw, err := bananogo.BananoToRaw("0.01")

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

    hash, err := client.Send(address, raw, seed, 0)

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

    fmt.Println("Block hash:", hash)
}

---

Short documentation

For more detailed documentation go to pkg.go.dev

---

Table of contents

• RPC interaction
  • Client
  • Send
  • Receive
  • Receive All
  • Change Representative
  • RPC
  • Get Account Balance
  • Get Account Info
  • Get Account History
  • Get Receivable
  • Get Representatives
  • Generate Work
  • Process
• Block creation and signing
  • Block
  • Sign
  • Add Work
• Conversion
  • Seed To Private Key
  • Private Key To Public Key
  • Public Key To Address
  • Address To Public Key
  • Banano To Raw
  • Raw To Banano
• Validation
  • Address Is Valid

RPC interaction

Client

The Client struct is used to interact with the Banano blockchain. It contains the URL of the RPC server, the authorization header and the authorization token.

client := bananogo.Client{
    Url: "Banano RPC URL",
    AuthHeader: "Authorization header", // if the RPC server requires an authorization
    AuthToken: "Authorization token" // if the RPC server requires an authorization
}

Send

The Send function sends Banano to an address. It requires the address, the raw amount, the seed and the account index. It returns the block hash or an error.

hash, err := client.Send(address, raw, seed, index)

Receive

The Receive function receives Banano from a block. It requires the block hash, the source address, the raw amount, the seed and the account index. It returns the block hash or an error.

hash, err := client.Receive(hash, sourceAddress, raw, seed, index)

Receive All

The ReceiveAll function receives all pending Banano. It requires the seed and the account index. It returns the block hashes or an error.

hashes, err := client.ReceiveAll(seed, index)

Change Representative

The ChangeRepresentative function changes the representative of an account. It requires the new representative, the seed and the account index. It returns the block hash or an error.

hash, err := client.ChangeRepresentative(representative, seed, index)

RPC

The RPC function sends a custom RPC request. It requires the data to send. It returns the response or an error.

response, err := client.RPC(data)

Get Account Balance

The GetAccountBalance function gets the balance of an account. It requires the address. It returns the balance or an error.

balance, err := client.GetAccountBalance(address)

Get Account Info

The GetAccountInfo function gets the information of an account. It requires the address. It returns the account info or an error.

info, err := client.GetAccountInfo(address)

Get Account History

The GetAccountHistory function gets the history of an account. It requires the address and the count (use -1 for all). It returns the account history or an error.

history, err := client.GetAccountHistory(address, count)

Get Receivable

The GetReceivable function gets the receivable blocks of an account. It requires the address. It returns the receivable blocks or an error.

receivable, err := client.GetReceivable(address)

Get Representatives

The GetRepresentatives function gets the online representatives. It returns the representatives or an error.

representatives, err := client.GetRepresentatives()

Generate Work

The GenerateWork function generates a work for a block hash. It requires the block. It returns the work or an error.

work, err := client.GenerateWork(block)

Process

The Process function processes a block. It requires the subtype and the block. It returns the block hash or an error.

hash, err := client.Process(subtype, block)

Block creation and signing

Block

The Block struct is used to create and sign blocks. It contains the type, the account, the previous block hash, the representative, the balance, the link, the link as account, the signature and the work.

block := bananogo.Block{
    Type: "type",
    Account: "wallet address",
    Previous: "previous block hash",
    Representative: "representative wallet address",
    Balance: "new balance in raw",
    Link: "link in hex",
    LinkAsAccount: "link as a wallet address",
    Signature: "block signature", // added after signing (not add manually)
    Work: "generated work", // added after generating work  (not add manually)
}

Sign

The Sign function signs a block. It requires the private key. It optionally returns an error.

err := block.Sign(privateKey)

Add Work

The AddWork function adds work to a block. It requires the work.

block.AddWork(work)

Conversion

Seed To Private Key

The SeedToPrivateKey function converts a seed to a private key. It requires the seed and the account index. It returns the private key or an error.

privateKey, err := bananogo.SeedToPrivateKey(seed, index)

Private Key To Public Key

The PrivateKeyToPublicKey function converts a private key to a public key. It requires the private key. It returns the public key or an error.

publicKey, err := bananogo.PrivateKeyToPublicKey(privateKey)

Public Key To Address

The PublicKeyToAddress function converts a public key to the wallet address. It requires the public key. It returns the address or an error.

address, err := bananogo.PublicKeyToAddress(publicKey)

Address To Public Key

The AddressToPublicKey function converts a wallet address to a public key. It requires the address. It returns the public key or an error.

publicKey, err := bananogo.AddressToPublicKey(address)

Banano To Raw

The BananoToRaw function converts Banano to raw. It requires the amount. It returns the raw amount or an error.

raw, err := bananogo.BananoToRaw(amount)

Raw To Banano

The RawToBanano function converts raw to Banano. It requires the raw amount. It returns the amount or an error.

banano, err := bananogo.RawToBanano(raw)

Validation

Address Is Valid

The AddressIsValid function checks if a wallet address is valid. It requires the address. It returns a boolean.

isValid := bananogo.AddressIsValid(address)