> For the complete documentation index, see [llms.txt](https://docs.endless.link/endless/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.endless.link/endless/devbuild/build/endless-sdks/go-sdk.md).

# Go SDK

## Endless Go SDK <a href="#endless-go-sdk" id="endless-go-sdk"></a>

## Installing the Go SDK <a href="#installing-the-go-sdk" id="installing-the-go-sdk"></a>

Endless provides an official Go SDK in the [Endless GitHub](https://github.com/endless-labs/endless-go-sdk) 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 <a href="#using-the-go-sdk" id="using-the-go-sdk"></a>

### **Creating a client**

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

```go
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()`.

```go
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

```go
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

```go
// 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](https://github.com/endless-labs/endless-go-sdk/tree/main/examples) of the Go SDK repository


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.endless.link/endless/devbuild/build/endless-sdks/go-sdk.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.