Go SDK

Endless Go SDK

Installing the Go SDK

Endless provides an official Go SDK in the Endless GitHub repository. To use the Go SDK, get the main package here:

go get github.com/endless-labs/endless-go-sdk

You can additionally add the bcs or crypto libraries

go get github.com/endless-labs/endless-go-sdk/bcs
go get github.com/endless-labs/endless-go-sdk/crypto

Using the Go SDK

Creating a client

You can create a client by importing the endless-go-sdk, and creating a Client

package example

import (
    github.com/endless-labs/endless-go-sdk
)

func test() {
	client, err := endless.NewClient(endless.TestnetConfig)
	if err != nil {
		panic("Failed to create client:" + err.Error())
	}
}

You can configure the network with the endless.NetworkConfig, or use a preexisting endless.DevnetConfig, endless.TestnetConfig, or endless.MainnetConfig

Creating a private key

You can create a new Ed25519 account's private key by calling NewEd25519Account().

account, err := endless.NewEd25519Account()
if err != nil {
  panic("Failed to create sender:" + err.Error())
}

Funding accounts

You can create and fund an account with a faucet on any network that is not mainnet

account, err := endless.NewEd25519Account()
if err != nil {
    panic("Failed to create sender:" + err.Error())
}

err = client.Faucet(*account, endless.SequenceNumber(0)) // Use the sequence number to skip fetching it
if err != nil {
    panic(fmt.Sprintf("Failed to fund account %s %w", account.AccountAddress(), err))
}

Sending a transaction

You can send a EndlessCoin via a transaction

// 1. Build transaction
entryFunction, err := endless.CoinTransferPayload(nil, endless.AccountOne, 100)
if err != nil {
    panic("Failed to build transfer payload:" + err.Error())
}
rawTxn, err := client.BuildTransaction(
    account.AccountAddress(),
    endless.TransactionPayload{
       Payload: entryFunction,
    },
)
if err != nil {
    panic("Failed to build transaction:" + err.Error())
}

// 2. Sign transaction
signedTxn, err := rawTxn.SignedTransaction(account)
if err != nil {
    panic("Failed to sign transaction:" + err.Error())
}

// 3. Submit transaction
submitResult, err := client.SubmitTransaction(signedTxn)
if err != nil {
    panic("Failed to submit transaction:" + err.Error())
}
txnHash := submitResult.Hash

// 4. Wait for the transaction to complete
userTransaction, err := client.WaitForTransaction(txnHash)
if err != nil {
    panic("Failed to wait for transaction:" + err.Error())
}
if !userTransaction.Success {
    panic("Failed to on chain success:" + userTransaction.VmStatus)
}
fmt.Printf("The transaction completed with hash: %s and version %d\n", userTransaction.Hash, userTransaction.Version)

More examples

You can see more examples in the examples/folder of the Go SDK repository