# 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: 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:

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

The question should be specific, self-contained, and written in natural language.
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.