go: github.com/stellar/go/clients/horizonclient Index | Examples | Files

package horizonclient

import "github.com/stellar/go/clients/horizonclient"

Package horizonclient provides client access to a Horizon server, allowing an application to post transactions and look up ledger information.

This library provides an interface to the Stellar Horizon service. It supports the building of Go applications on top of the Stellar network (https://www.stellar.org/). Transactions may be constructed using the sister package to this one, txnbuild (https://github.com/stellar/go/tree/master/txnbuild), and then submitted with this client to any Horizon instance for processing onto the ledger. Together, these two libraries provide a complete Stellar SDK.

For more information and further examples, see https://www.stellar.org/developers/go/reference/index.html.

Index

Examples

Package Files

account_request.go asset_request.go client.go effect_request.go error.go fee_stats_request.go internal.go ledger_request.go main.go metrics_request.go mocks.go offer_request.go operation_request.go order_book_request.go paths_request.go submit_request.go trade_aggregation_request.go trade_request.go transaction_request.go version.go

Constants

const (
    // OrderAsc represents an ascending order parameter
    OrderAsc Order = "asc"
    // OrderDesc represents an descending order parameter
    OrderDesc Order = "desc"
    // AssetType4 represents an asset type that is 4 characters long
    AssetType4 AssetType = "credit_alphanum4"
    // AssetType12 represents an asset type that is 12 characters long
    AssetType12 AssetType = "credit_alphanum12"
    // AssetTypeNative represents the asset type for Stellar Lumens (XLM)
    AssetTypeNative AssetType = "native"
)

Variables

var (
    // ErrResultCodesNotPopulated is the error returned from a call to
    // ResultCodes() against a `Problem` value that doesn't have the
    // "result_codes" extra field populated when it is expected to be.
    ErrResultCodesNotPopulated = errors.New("result_codes not populated")

    // ErrEnvelopeNotPopulated is the error returned from a call to
    // Envelope() against a `Problem` value that doesn't have the
    // "envelope_xdr" extra field populated when it is expected to be.
    ErrEnvelopeNotPopulated = errors.New("envelope_xdr not populated")

    // ErrResultNotPopulated is the error returned from a call to
    // Result() against a `Problem` value that doesn't have the
    // "result_xdr" extra field populated when it is expected to be.
    ErrResultNotPopulated = errors.New("result_xdr not populated")

    // HorizonTimeOut is the default number of seconds before a request to horizon times out.
    HorizonTimeOut = time.Duration(60)

    // MinuteResolution represents 1 minute used as `resolution` parameter in trade aggregation
    MinuteResolution = time.Duration(1 * time.Minute)

    // FiveMinuteResolution represents 5 minutes used as `resolution` parameter in trade aggregation
    FiveMinuteResolution = time.Duration(5 * time.Minute)

    // FifteenMinuteResolution represents 15 minutes used as `resolution` parameter in trade aggregation
    FifteenMinuteResolution = time.Duration(15 * time.Minute)

    // HourResolution represents 1 hour used as `resolution` parameter in trade aggregation
    HourResolution = time.Duration(1 * time.Hour)

    // DayResolution represents 1 day used as `resolution` parameter in trade aggregation
    DayResolution = time.Duration(24 * time.Hour)

    // WeekResolution represents 1 week used as `resolution` parameter in trade aggregation
    WeekResolution = time.Duration(168 * time.Hour)
)
var DefaultPublicNetClient = &Client{
    HorizonURL:           "https://horizon.stellar.org/",
    HTTP:                 http.DefaultClient,
    horizonTimeOut:       HorizonTimeOut,
    currentUniversalTime: universalTimeFunc,
}

DefaultPublicNetClient is a default client to connect to public network.

var DefaultTestNetClient = &Client{
    HorizonURL:           "https://horizon-testnet.stellar.org/",
    HTTP:                 http.DefaultClient,
    horizonTimeOut:       HorizonTimeOut,
    isTestNet:            true,
    currentUniversalTime: universalTimeFunc,
}

DefaultTestNetClient is a default client to connect to test network.

var ServerTimeMap = make(map[string]ServerTimeRecord)

ServerTimeMap holds the ServerTimeRecord for different horizon instances.

type AccountRequest Uses

type AccountRequest struct {
    AccountID string
    DataKey   string
}

AccountRequest struct contains data for making requests to the accounts endpoint of a horizon server. "AccountID" and "DataKey" fields should both be set when retrieving AccountData. When getting the AccountDetail, only "AccountID" needs to be set.

func (AccountRequest) BuildURL Uses

func (ar AccountRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the AccountRequest struct. If only AccountID is present, then the endpoint for account details is returned. If both AccounId and DataKey are present, then the endpoint for getting account data is returned

type AssetRequest Uses

type AssetRequest struct {
    ForAssetCode   string
    ForAssetIssuer string
    Order          Order
    Cursor         string
    Limit          uint
}

AssetRequest struct contains data for getting asset details from a horizon server. If "ForAssetCode" and "ForAssetIssuer" are not set, it returns all assets. The query parameters (Order, Cursor and Limit) are optional. All or none can be set.

func (AssetRequest) BuildURL Uses

func (ar AssetRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the AssetRequest struct. If no data is set, it defaults to the build the URL for all assets

type AssetType Uses

type AssetType string

AssetType represents `asset_type` param in queries

type Client Uses

type Client struct {
    // URL of Horizon server to connect
    HorizonURL string

    // HTTP client to make requests with
    HTTP HTTP

    // AppName is the name of the application using the horizonclient package
    AppName string

    // AppVersion is the version of the application using the horizonclient package
    AppVersion string
    // contains filtered or unexported fields
}

Client struct contains data for creating a horizon client that connects to the stellar network.

func (*Client) AccountData Uses

func (c *Client) AccountData(request AccountRequest) (accountData hProtocol.AccountData, err error)

AccountData returns a single data associated with a given account See https://www.stellar.org/developers/horizon/reference/endpoints/data-for-account.html

func (*Client) AccountDetail Uses

func (c *Client) AccountDetail(request AccountRequest) (account hProtocol.Account, err error)

AccountDetail returns information for a single account. See https://www.stellar.org/developers/horizon/reference/endpoints/accounts-single.html

Code:


client := DefaultPublicNetClient
accountRequest := AccountRequest{AccountID: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}

account, err := client.AccountDetail(accountRequest)
if err != nil {
    fmt.Println(err)
    return
}

fmt.Print(account)

func (*Client) Assets Uses

func (c *Client) Assets(request AssetRequest) (assets hProtocol.AssetsPage, err error)

Assets returns asset information. See https://www.stellar.org/developers/horizon/reference/endpoints/assets-all.html

Code:


client := DefaultPublicNetClient
// assets for asset issuer
assetRequest := AssetRequest{ForAssetIssuer: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
asset, err := client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(asset)

// all assets
assetRequest = AssetRequest{}
asset, err = client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(asset)

func (*Client) Effects Uses

func (c *Client) Effects(request EffectRequest) (effects effects.EffectsPage, err error)

Effects returns effects(https://www.stellar.org/developers/horizon/reference/resources/effect.html) It can be used to return effects for an account, a ledger, an operation, a transaction and all effects on the network.

Code:


client := DefaultPublicNetClient
// effects for an account
effectRequest := EffectRequest{ForAccount: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
effect, err := client.Effects(effectRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(effect)

// all effects
effectRequest = EffectRequest{}
effect, err = client.Effects(effectRequest)
if err != nil {
    fmt.Println(err)
    return
}
records := effect.Embedded.Records
if records[0].GetType() == "account_created" {
    acc, ok := records[0].(effects.AccountCreated)
    if ok {
        fmt.Print(acc.Account)
        fmt.Print(acc.StartingBalance)
    }
}

func (*Client) FeeStats Uses

func (c *Client) FeeStats() (feestats hProtocol.FeeStats, err error)

FeeStats returns information about fees in the last 5 ledgers. See https://www.stellar.org/developers/horizon/reference/endpoints/fee-stats.html

Code:


client := DefaultPublicNetClient
// horizon fees
fees, err := client.FeeStats()
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(fees)

func (*Client) FetchTimebounds Uses

func (c *Client) FetchTimebounds(seconds int64) (txnbuild.Timebounds, error)

FetchTimebounds provides timebounds for N seconds from now using the server time of the horizon instance. It defaults to localtime when the server time is not available. Note that this will generate your timebounds when you init the transaction, not when you build or submit the transaction! So give yourself enough time to get the transaction built and signed before submitting.

func (*Client) Fund Uses

func (c *Client) Fund(addr string) (txSuccess hProtocol.TransactionSuccess, err error)

Fund creates a new account funded from friendbot. It only works on test networks. See https://www.stellar.org/developers/guides/get-started/create-account.html for more information.

Code:

client := DefaultTestNetClient
// fund an account
resp, err := client.Fund("GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU")
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(resp)

func (*Client) HomeDomainForAccount Uses

func (c *Client) HomeDomainForAccount(aid string) (string, error)

HomeDomainForAccount returns the home domain for a single account.

func (*Client) HorizonTimeOut Uses

func (c *Client) HorizonTimeOut() time.Duration

HorizonTimeOut returns the current timeout for a horizon client

func (*Client) LedgerDetail Uses

func (c *Client) LedgerDetail(sequence uint32) (ledger hProtocol.Ledger, err error)

LedgerDetail returns information about a particular ledger for a given sequence number See https://www.stellar.org/developers/horizon/reference/endpoints/ledgers-single.html

Code:


client := DefaultPublicNetClient
// details for a ledger
sequence := uint32(12345)
ledger, err := client.LedgerDetail(sequence)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ledger)

func (*Client) Ledgers Uses

func (c *Client) Ledgers(request LedgerRequest) (ledgers hProtocol.LedgersPage, err error)

Ledgers returns information about all ledgers. See https://www.stellar.org/developers/horizon/reference/endpoints/ledgers-all.html

func (*Client) Metrics Uses

func (c *Client) Metrics() (metrics hProtocol.Metrics, err error)

Metrics returns monitoring information about a horizon server See https://www.stellar.org/developers/horizon/reference/endpoints/metrics.html

Code:


client := DefaultPublicNetClient
// horizon metrics
metrics, err := client.Metrics()
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(metrics)

func (*Client) NextAssetsPage Uses

func (c *Client) NextAssetsPage(page hProtocol.AssetsPage) (assets hProtocol.AssetsPage, err error)

NextAssetsPage returns the next page of assets.

Code:

client := DefaultPublicNetClient
// assets for asset issuer
assetRequest := AssetRequest{ForAssetIssuer: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU",
    Limit: 20}
asset, err := client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(asset)

// all assets
assetRequest = AssetRequest{}
asset, err = client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}

// next page
nextPage, err := client.NextAssetsPage(asset)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(nextPage)

func (*Client) NextEffectsPage Uses

func (c *Client) NextEffectsPage(page effects.EffectsPage) (efp effects.EffectsPage, err error)

NextEffectsPage returns the next page of effects.

Code:

client := DefaultPublicNetClient
// all effects
effectRequest := EffectRequest{Limit: 20}
efp, err := client.Effects(effectRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(efp)

// get next pages.
recordsFound := false
if len(efp.Embedded.Records) > 0 {
    recordsFound = true
}
page := efp
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextEffectsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextLedgersPage Uses

func (c *Client) NextLedgersPage(page hProtocol.LedgersPage) (ledgers hProtocol.LedgersPage, err error)

NextLedgersPage returns the next page of ledgers.

Code:

client := DefaultPublicNetClient
// all ledgers
ledgerRequest := LedgerRequest{Limit: 20}
ledgers, err := client.Ledgers(ledgerRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ledgers)

// get next pages.
recordsFound := false
if len(ledgers.Embedded.Records) > 0 {
    recordsFound = true
}
page := ledgers
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextLedgersPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextOffersPage Uses

func (c *Client) NextOffersPage(page hProtocol.OffersPage) (offers hProtocol.OffersPage, err error)

NextOffersPage returns the next page of offers.

Code:

client := DefaultPublicNetClient
// all offers
offerRequest := OfferRequest{ForAccount: "GAQHWQYBBW272OOXNQMMLCA5WY2XAZPODGB7Q3S5OKKIXVESKO55ZQ7C", Limit: 20}
offers, err := client.Offers(offerRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(offers)

// get next pages.
recordsFound := false
if len(offers.Embedded.Records) > 0 {
    recordsFound = true
}
page := offers
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextOffersPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextOperationsPage Uses

func (c *Client) NextOperationsPage(page operations.OperationsPage) (operations operations.OperationsPage, err error)

NextOperationsPage returns the next page of operations.

Code:

client := DefaultPublicNetClient
// all operations
operationRequest := OperationRequest{Limit: 20}
ops, err := client.Operations(operationRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)

// get next pages.
recordsFound := false
if len(ops.Embedded.Records) > 0 {
    recordsFound = true
}
page := ops
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextOperationsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextPaymentsPage Uses

func (c *Client) NextPaymentsPage(page operations.OperationsPage) (operations.OperationsPage, error)

NextPaymentsPage returns the next page of payments.

func (*Client) NextTradeAggregationsPage Uses

func (c *Client) NextTradeAggregationsPage(page hProtocol.TradeAggregationsPage) (ta hProtocol.TradeAggregationsPage, err error)

NextTradeAggregationsPage returns the next page of trade aggregations from the current trade aggregations response.

Code:

client := DefaultPublicNetClient
// Find trade aggregations
ta := TradeAggregationRequest{
    StartTime:          testTime,
    EndTime:            testTime,
    Resolution:         FiveMinuteResolution,
    BaseAssetType:      AssetTypeNative,
    CounterAssetType:   AssetType4,
    CounterAssetCode:   "SLT",
    CounterAssetIssuer: "GCKA6K5PCQ6PNF5RQBF7PQDJWRHO6UOGFMRLK3DYHDOI244V47XKQ4GP",
    Order:              OrderDesc,
}
tradeAggs, err := client.TradeAggregations(ta)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(tradeAggs)

// get next pages.
recordsFound := false
if len(tradeAggs.Embedded.Records) > 0 {
    recordsFound = true
}
page := tradeAggs
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextTradeAggregationsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextTradesPage Uses

func (c *Client) NextTradesPage(page hProtocol.TradesPage) (trades hProtocol.TradesPage, err error)

NextTradesPage returns the next page of trades.

Code:

client := DefaultPublicNetClient
// all trades
tradeRequest := TradeRequest{Cursor: "123456", Limit: 30, Order: OrderAsc}
trades, err := client.Trades(tradeRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(trades)

// get next pages.
recordsFound := false
if len(trades.Embedded.Records) > 0 {
    recordsFound = true
}
page := trades
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextTradesPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) NextTransactionsPage Uses

func (c *Client) NextTransactionsPage(page hProtocol.TransactionsPage) (transactions hProtocol.TransactionsPage, err error)

NextTransactionsPage returns the next page of transactions.

Code:

client := DefaultPublicNetClient
// all transactions
transactionRequest := TransactionRequest{Limit: 20}
transactions, err := client.Transactions(transactionRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(transactions)

// get next pages.
recordsFound := false
if len(transactions.Embedded.Records) > 0 {
    recordsFound = true
}
page := transactions
// get the next page of records if recordsFound is true
for recordsFound {
    // next page
    nextPage, err := client.NextTransactionsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = nextPage
    if len(nextPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(nextPage)
}

func (*Client) Offers Uses

func (c *Client) Offers(request OfferRequest) (offers hProtocol.OffersPage, err error)

Offers returns information about offers made on the SDEX. See https://www.stellar.org/developers/horizon/reference/endpoints/offers-for-account.html

Code:


client := DefaultPublicNetClient
offerRequest := OfferRequest{ForAccount: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU", Cursor: "now", Order: OrderDesc}
offers, err := client.Offers(offerRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(offers)

func (*Client) OperationDetail Uses

func (c *Client) OperationDetail(id string) (ops operations.Operation, err error)

OperationDetail returns a single stellar operations (https://www.stellar.org/developers/horizon/reference/resources/operation.html) for a given operation id

Code:


client := DefaultPublicNetClient
opID := "123456"
// operation details for an id
ops, err := client.OperationDetail(opID)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)

func (*Client) Operations Uses

func (c *Client) Operations(request OperationRequest) (ops operations.OperationsPage, err error)

Operations returns stellar operations (https://www.stellar.org/developers/horizon/reference/resources/operation.html) It can be used to return operations for an account, a ledger, a transaction and all operations on the network.

Code:


client := DefaultPublicNetClient
// operations for an account
opRequest := OperationRequest{ForAccount: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
ops, err := client.Operations(opRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)

// all operations
opRequest = OperationRequest{Cursor: "now"}
ops, err = client.Operations(opRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)
records := ops.Embedded.Records

for _, value := range records {
    // prints the type
    fmt.Print(value.GetType())
    // for example if the type is change_trust
    c, ok := value.(operations.ChangeTrust)
    if ok {
        // access ChangeTrust fields
        fmt.Print(c.Trustee)
    }

}

func (*Client) OrderBook Uses

func (c *Client) OrderBook(request OrderBookRequest) (obs hProtocol.OrderBookSummary, err error)

OrderBook returns the orderbook for an asset pair (https://www.stellar.org/developers/horizon/reference/resources/orderbook.html)

Code:


client := DefaultPublicNetClient
// orderbook for an asset pair, e.g XLM/NGN
obRequest := OrderBookRequest{BuyingAssetType: AssetTypeNative, SellingAssetCode: "USD", SellingAssetType: AssetType4, SellingAssetIssuer: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
obs, err := client.OrderBook(obRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(obs)

func (*Client) Paths Uses

func (c *Client) Paths(request PathsRequest) (paths hProtocol.PathsPage, err error)

Paths returns the available paths to make a payment. See https://www.stellar.org/developers/horizon/reference/endpoints/path-finding.html

Code:


client := DefaultPublicNetClient
// Find paths for XLM->NGN
pr := PathsRequest{
    DestinationAccount:     "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU",
    DestinationAmount:      "100",
    DestinationAssetCode:   "NGN",
    DestinationAssetIssuer: "GDZST3XVCDTUJ76ZAV2HA72KYQODXXZ5PTMAPZGDHZ6CS7RO7MGG3DBM",
    DestinationAssetType:   AssetType4,
    SourceAccount:          "GDZST3XVCDTUJ76ZAV2HA72KYQODXXZ5PTMAPZGDHZ6CS7RO7MGG3DBM",
}
paths, err := client.Paths(pr)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(paths)

func (*Client) Payments Uses

func (c *Client) Payments(request OperationRequest) (ops operations.OperationsPage, err error)

Payments returns stellar account_merge, create_account, path payment and payment operations. It can be used to return payments for an account, a ledger, a transaction and all payments on the network.

Code:


client := DefaultPublicNetClient
// payments for an account
opRequest := OperationRequest{ForAccount: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
ops, err := client.Payments(opRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)

// all payments
opRequest = OperationRequest{Cursor: "now"}
ops, err = client.Payments(opRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)
records := ops.Embedded.Records

for _, value := range records {
    // prints the type
    fmt.Print(value.GetType())
    // for example if the type is create_account
    c, ok := value.(operations.CreateAccount)
    if ok {
        // access create_account fields
        fmt.Print(c.StartingBalance)
    }

}

func (*Client) PrevAssetsPage Uses

func (c *Client) PrevAssetsPage(page hProtocol.AssetsPage) (assets hProtocol.AssetsPage, err error)

PrevAssetsPage returns the previous page of assets.

Code:

client := DefaultPublicNetClient
// assets for asset issuer
assetRequest := AssetRequest{ForAssetIssuer: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU",
    Limit: 20}
asset, err := client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(asset)

// all assets
assetRequest = AssetRequest{}
asset, err = client.Assets(assetRequest)
if err != nil {
    fmt.Println(err)
    return
}

// next page
prevPage, err := client.PrevAssetsPage(asset)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Println(prevPage)

func (*Client) PrevEffectsPage Uses

func (c *Client) PrevEffectsPage(page effects.EffectsPage) (efp effects.EffectsPage, err error)

PrevEffectsPage returns the previous page of effects.

Code:

client := DefaultPublicNetClient
// all effects
effectRequest := EffectRequest{Limit: 20}
efp, err := client.Effects(effectRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(efp)

// get prev pages.
recordsFound := false
if len(efp.Embedded.Records) > 0 {
    recordsFound = true
}
page := efp
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevEffectsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevLedgersPage Uses

func (c *Client) PrevLedgersPage(page hProtocol.LedgersPage) (ledgers hProtocol.LedgersPage, err error)

PrevLedgersPage returns the previous page of ledgers.

Code:

client := DefaultPublicNetClient
// all ledgers
ledgerRequest := LedgerRequest{Limit: 20}
ledgers, err := client.Ledgers(ledgerRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ledgers)

// get prev pages.
recordsFound := false
if len(ledgers.Embedded.Records) > 0 {
    recordsFound = true
}
page := ledgers
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevLedgersPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevOffersPage Uses

func (c *Client) PrevOffersPage(page hProtocol.OffersPage) (offers hProtocol.OffersPage, err error)

PrevOffersPage returns the previous page of offers.

Code:

client := DefaultPublicNetClient
// all offers
offerRequest := OfferRequest{ForAccount: "GAQHWQYBBW272OOXNQMMLCA5WY2XAZPODGB7Q3S5OKKIXVESKO55ZQ7C", Limit: 20}
offers, err := client.Offers(offerRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(offers)

// get prev pages.
recordsFound := false
if len(offers.Embedded.Records) > 0 {
    recordsFound = true
}
page := offers
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevOffersPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevOperationsPage Uses

func (c *Client) PrevOperationsPage(page operations.OperationsPage) (operations operations.OperationsPage, err error)

PrevOperationsPage returns the previous page of operations.

Code:

client := DefaultPublicNetClient
// all operations
operationRequest := OperationRequest{Limit: 20}
ops, err := client.Operations(operationRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(ops)

// get prev pages.
recordsFound := false
if len(ops.Embedded.Records) > 0 {
    recordsFound = true
}
page := ops
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevOperationsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevPaymentsPage Uses

func (c *Client) PrevPaymentsPage(page operations.OperationsPage) (operations.OperationsPage, error)

PrevPaymentsPage returns the previous page of payments.

func (*Client) PrevTradeAggregationsPage Uses

func (c *Client) PrevTradeAggregationsPage(page hProtocol.TradeAggregationsPage) (ta hProtocol.TradeAggregationsPage, err error)

PrevTradeAggregationsPage returns the previous page of trade aggregations from the current trade aggregations response.

Code:

client := DefaultPublicNetClient
// Find trade aggregations
ta := TradeAggregationRequest{
    StartTime:          testTime,
    EndTime:            testTime,
    Resolution:         FiveMinuteResolution,
    BaseAssetType:      AssetTypeNative,
    CounterAssetType:   AssetType4,
    CounterAssetCode:   "SLT",
    CounterAssetIssuer: "GCKA6K5PCQ6PNF5RQBF7PQDJWRHO6UOGFMRLK3DYHDOI244V47XKQ4GP",
    Order:              OrderDesc,
}
tradeAggs, err := client.TradeAggregations(ta)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(tradeAggs)

// get prev pages.
recordsFound := false
if len(tradeAggs.Embedded.Records) > 0 {
    recordsFound = true
}
page := tradeAggs
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevTradeAggregationsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevTradesPage Uses

func (c *Client) PrevTradesPage(page hProtocol.TradesPage) (trades hProtocol.TradesPage, err error)

PrevTradesPage returns the previous page of trades.

Code:

client := DefaultPublicNetClient
// all trades
tradeRequest := TradeRequest{Cursor: "123456", Limit: 30, Order: OrderAsc}
trades, err := client.Trades(tradeRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(trades)

// get prev pages.
recordsFound := false
if len(trades.Embedded.Records) > 0 {
    recordsFound = true
}
page := trades
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevTradesPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) PrevTransactionsPage Uses

func (c *Client) PrevTransactionsPage(page hProtocol.TransactionsPage) (transactions hProtocol.TransactionsPage, err error)

PrevTransactionsPage returns the previous page of transactions.

Code:

client := DefaultPublicNetClient
// all transactions
transactionRequest := TransactionRequest{Limit: 20}
transactions, err := client.Transactions(transactionRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(transactions)

// get prev pages.
recordsFound := false
if len(transactions.Embedded.Records) > 0 {
    recordsFound = true
}
page := transactions
// get the prev page of records if recordsFound is true
for recordsFound {
    // prev page
    prevPage, err := client.PrevTransactionsPage(page)
    if err != nil {
        fmt.Println(err)
        return
    }

    page = prevPage
    if len(prevPage.Embedded.Records) == 0 {
        recordsFound = false
    }
    fmt.Println(prevPage)
}

func (*Client) Root Uses

func (c *Client) Root() (root hProtocol.Root, err error)

Root loads the root endpoint of horizon

Code:

client := DefaultTestNetClient
root, err := client.Root()
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(root)

func (*Client) SetCurrentUniversalTime Uses

func (c *Client) SetCurrentUniversalTime(handler UniversalTimeHandler)

SetCurrentUniversalTime sets the currentUniversalTime function to the provided handler function. Users can use this method to set a custom handler function.

func (*Client) SetHorizonTimeOut Uses

func (c *Client) SetHorizonTimeOut(t uint) *Client

SetHorizonTimeOut allows users to set the number of seconds before a horizon request is cancelled.

Code:


client := DefaultTestNetClient

// https://www.stellar.org/laboratory/#xdr-viewer?input=AAAAABB90WssODNIgi6BHveqzxTRmIpvAFRyVNM%2BHm2GVuCcAAAAZAAABD0AAuV%2FAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAyTBGxOgfSApppsTnb%2FYRr6gOR8WT0LZNrhLh4y3FCgoAAAAXSHboAAAAAAAAAAABhlbgnAAAAEAivKe977CQCxMOKTuj%2BcWTFqc2OOJU8qGr9afrgu2zDmQaX5Q0cNshc3PiBwe0qw%2F%2BD%2FqJk5QqM5dYeSUGeDQP&type=TransactionEnvelope&network=test
txXdr := `AAAAABB90WssODNIgi6BHveqzxTRmIpvAFRyVNM+Hm2GVuCcAAAAZAAABD0AAuV/AAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAyTBGxOgfSApppsTnb/YRr6gOR8WT0LZNrhLh4y3FCgoAAAAXSHboAAAAAAAAAAABhlbgnAAAAEAivKe977CQCxMOKTuj+cWTFqc2OOJU8qGr9afrgu2zDmQaX5Q0cNshc3PiBwe0qw/+D/qJk5QqM5dYeSUGeDQP`

// test user timeout
client = client.SetHorizonTimeOut(30)
resp, err := client.SubmitTransactionXDR(txXdr)
if err != nil {
    fmt.Println(err)
    return
}

fmt.Print(resp)

func (*Client) StreamEffects Uses

func (c *Client) StreamEffects(ctx context.Context, request EffectRequest, handler EffectHandler) error

StreamEffects streams horizon effects. It can be used to stream all effects or account specific effects. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. EffectHandler is a user-supplied function that is executed for each streamed transaction received.

Code:

client := DefaultTestNetClient
// all effects
effectRequest := EffectRequest{Cursor: "760209215489"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(e effects.Effect) {
    fmt.Println(e)
}
err := client.StreamEffects(ctx, effectRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamLedgers Uses

func (c *Client) StreamLedgers(ctx context.Context, request LedgerRequest, handler LedgerHandler) error

StreamLedgers streams stellar ledgers. It can be used to stream all ledgers. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. LedgerHandler is a user-supplied function that is executed for each streamed ledger received.

Code:

client := DefaultTestNetClient
// all ledgers from now
ledgerRequest := LedgerRequest{}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(ledger hProtocol.Ledger) {
    fmt.Println(ledger)
}
err := client.StreamLedgers(ctx, ledgerRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamOffers Uses

func (c *Client) StreamOffers(ctx context.Context, request OfferRequest, handler OfferHandler) error

StreamOffers streams offers processed by the Stellar network for an account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OfferHandler is a user-supplied function that is executed for each streamed offer received.

Code:

client := DefaultTestNetClient
// offers for account
offerRequest := OfferRequest{ForAccount: "GAQHWQYBBW272OOXNQMMLCA5WY2XAZPODGB7Q3S5OKKIXVESKO55ZQ7C", Cursor: "1"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(offer hProtocol.Offer) {
    fmt.Println(offer)
}
err := client.StreamOffers(ctx, offerRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamOperations Uses

func (c *Client) StreamOperations(ctx context.Context, request OperationRequest, handler OperationHandler) error

StreamOperations streams stellar operations. It can be used to stream all operations or operations for an account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OperationHandler is a user-supplied function that is executed for each streamed

operation received.

Code:

client := DefaultTestNetClient
// operations for an account
opRequest := OperationRequest{ForAccount: "GAIH3ULLFQ4DGSECF2AR555KZ4KNDGEKN4AFI4SU2M7B43MGK3QJZNSR", Cursor: "760209215489"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(op operations.Operation) {
    fmt.Println(op)
}
err := client.StreamOperations(ctx, opRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamOrderBooks Uses

func (c *Client) StreamOrderBooks(ctx context.Context, request OrderBookRequest, handler OrderBookHandler) error

StreamOrderBooks streams the orderbook for a given asset pair. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OrderBookHandler is a user-supplied function that is executed for each streamed order received.

Code:

client := DefaultTestNetClient
orderbookRequest := OrderBookRequest{SellingAssetType: AssetTypeNative, BuyingAssetType: AssetType4, BuyingAssetCode: "ABC", BuyingAssetIssuer: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(orderbook hProtocol.OrderBookSummary) {
    fmt.Println(orderbook)
}
err := client.StreamOrderBooks(ctx, orderbookRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamPayments Uses

func (c *Client) StreamPayments(ctx context.Context, request OperationRequest, handler OperationHandler) error

StreamPayments streams stellar payments. It can be used to stream all payments or payments for an account. Payments include create_account, payment, path_payment and account_merge operations. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OperationHandler is a user-supplied function that is executed for each streamed

operation received.

Code:

client := DefaultTestNetClient
// all payments
opRequest := OperationRequest{Cursor: "760209215489"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(op operations.Operation) {
    fmt.Println(op)
}
err := client.StreamPayments(ctx, opRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) StreamTrades Uses

func (c *Client) StreamTrades(ctx context.Context, request TradeRequest, handler TradeHandler) (err error)

StreamTrades streams executed trades. It can be used to stream all trades, trades for an account and trades for an offer. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. TradeHandler is a user-supplied function that is executed for each streamed trade received.

Code:

client := DefaultTestNetClient
// all trades
tradeRequest := TradeRequest{Cursor: "760209215489"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(tr hProtocol.Trade) {
    fmt.Println(tr)
}
err := client.StreamTrades(ctx, tradeRequest, printHandler)

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

func (*Client) StreamTransactions Uses

func (c *Client) StreamTransactions(ctx context.Context, request TransactionRequest, handler TransactionHandler) error

StreamTransactions streams processed transactions. It can be used to stream all transactions and transactions for an account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. TransactionHandler is a user-supplied function that is executed for each streamed transaction received.

Code:

client := DefaultTestNetClient
// all transactions
transactionRequest := TransactionRequest{Cursor: "760209215489"}

ctx, cancel := context.WithCancel(context.Background())
go func() {
    // Stop streaming after 60 seconds.
    time.Sleep(60 * time.Second)
    cancel()
}()

printHandler := func(tr hProtocol.Transaction) {
    fmt.Println(tr)
}
err := client.StreamTransactions(ctx, transactionRequest, printHandler)
if err != nil {
    fmt.Println(err)
}

func (*Client) SubmitTransaction Uses

func (c *Client) SubmitTransaction(transaction txnbuild.Transaction) (txSuccess hProtocol.TransactionSuccess,
    err error)

SubmitTransaction submits a transaction to the network. err can be either error object or horizon.Error object. See https://www.stellar.org/developers/horizon/reference/endpoints/transactions-create.html

func (*Client) SubmitTransactionXDR Uses

func (c *Client) SubmitTransactionXDR(transactionXdr string) (txSuccess hProtocol.TransactionSuccess,
    err error)

SubmitTransactionXDR submits a transaction represented as a base64 XDR string to the network. err can be either error object or horizon.Error object. See https://www.stellar.org/developers/horizon/reference/endpoints/transactions-create.html

Code:

client := DefaultPublicNetClient
// https://www.stellar.org/laboratory/#xdr-viewer?input=AAAAAOoS%2F5V%2BBiCPXRiVcz8YsnkDdODufq%2Bg7xdqTdIXN8vyAAAE4gFiW0YAAALxAAAAAQAAAAAAAAAAAAAAAFyuBUcAAAABAAAABzIyMjgyNDUAAAAAAQAAAAEAAAAALhsY%2FFdAHXllTmb025DtCVBw06WDSQjq6I9NrCQHOV8AAAABAAAAAHT8zKV7bRQzuGTpk9AO3gjWJ9jVxBXTgguFORkxHVIKAAAAAAAAAAAAOnDwAAAAAAAAAAIkBzlfAAAAQPefqlsOvni6xX1g3AqddvOp1GOM88JYzayGZodbzTfV5toyhxZvL1ZggY3prFsvrereugEpj1kyPJ67z6gcRg0XN8vyAAAAQGwmoTssW49gaze8iQkz%2FUA2E2N%2BBOo%2B6v7YdOSsvIcZnMc37KmXH920nLosKpDLqkNChVztSZFcbVUlHhjbQgA%3D&type=TransactionEnvelope&network=public
txXdr := `AAAAAOoS/5V+BiCPXRiVcz8YsnkDdODufq+g7xdqTdIXN8vyAAAE4gFiW0YAAALxAAAAAQAAAAAAAAAAAAAAAFyuBUcAAAABAAAABzIyMjgyNDUAAAAAAQAAAAEAAAAALhsY/FdAHXllTmb025DtCVBw06WDSQjq6I9NrCQHOV8AAAABAAAAAHT8zKV7bRQzuGTpk9AO3gjWJ9jVxBXTgguFORkxHVIKAAAAAAAAAAAAOnDwAAAAAAAAAAIkBzlfAAAAQPefqlsOvni6xX1g3AqddvOp1GOM88JYzayGZodbzTfV5toyhxZvL1ZggY3prFsvrereugEpj1kyPJ67z6gcRg0XN8vyAAAAQGwmoTssW49gaze8iQkz/UA2E2N+BOo+6v7YdOSsvIcZnMc37KmXH920nLosKpDLqkNChVztSZFcbVUlHhjbQgA=`

// submit transaction
resp, err := client.SubmitTransactionXDR(txXdr)
if err != nil {
    fmt.Println(err)
    return
}

fmt.Print(resp)

Output:

{{{https://horizon.stellar.org/transactions/f8a09e8a17fc828a1b99814818ddc931876eec0fe9c203f5980d26d92641e1c2 false}} f8a09e8a17fc828a1b99814818ddc931876eec0fe9c203f5980d26d92641e1c2 23350654 AAAAAOoS/5V+BiCPXRiVcz8YsnkDdODufq+g7xdqTdIXN8vyAAAE4gFiW0YAAALxAAAAAQAAAAAAAAAAAAAAAFyuBUcAAAABAAAABzIyMjgyNDUAAAAAAQAAAAEAAAAALhsY/FdAHXllTmb025DtCVBw06WDSQjq6I9NrCQHOV8AAAABAAAAAHT8zKV7bRQzuGTpk9AO3gjWJ9jVxBXTgguFORkxHVIKAAAAAAAAAAAAOnDwAAAAAAAAAAIkBzlfAAAAQPefqlsOvni6xX1g3AqddvOp1GOM88JYzayGZodbzTfV5toyhxZvL1ZggY3prFsvrereugEpj1kyPJ67z6gcRg0XN8vyAAAAQGwmoTssW49gaze8iQkz/UA2E2N+BOo+6v7YdOSsvIcZnMc37KmXH920nLosKpDLqkNChVztSZFcbVUlHhjbQgA= AAAAAAAABOIAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAA= AAAAAQAAAAIAAAADAWRNfgAAAAAAAAAA6hL/lX4GII9dGJVzPxiyeQN04O5+r6DvF2pN0hc3y/IAAAAAAuyTvgFiW0YAAALwAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABAWRNfgAAAAAAAAAA6hL/lX4GII9dGJVzPxiyeQN04O5+r6DvF2pN0hc3y/IAAAAAAuyTvgFiW0YAAALxAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAABAAAABAAAAAMBZE0IAAAAAAAAAAB0/Myle20UM7hk6ZPQDt4I1ifY1cQV04ILhTkZMR1SCgAAAbZToYkOAToKfwAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAEBZE1+AAAAAAAAAAB0/Myle20UM7hk6ZPQDt4I1ifY1cQV04ILhTkZMR1SCgAAAbZT2/n+AToKfwAAAAEAAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAMBZE19AAAAAAAAAAAuGxj8V0AdeWVOZvTbkO0JUHDTpYNJCOroj02sJAc5XwAAAACrUfjvARGUKgAApRsAAAAAAAAAAAAAAAAAAAAObnlhbmRldi1pZC5vcmcAAAEAAAAAAAAAAAAAAAAAAAAAAAABAWRNfgAAAAAAAAAALhsY/FdAHXllTmb025DtCVBw06WDSQjq6I9NrCQHOV8AAAAAqxeH/wERlCoAAKUbAAAAAAAAAAAAAAAAAAAADm55YW5kZXYtaWQub3JnAAABAAAAAAAAAAAAAAAAAAAA}

func (*Client) TradeAggregations Uses

func (c *Client) TradeAggregations(request TradeAggregationRequest) (tds hProtocol.TradeAggregationsPage, err error)

TradeAggregations returns stellar trade aggregations (https://www.stellar.org/developers/horizon/reference/resources/trade_aggregation.html)

Code:


client := DefaultPublicNetClient
// Find trade aggregations
ta := TradeAggregationRequest{
    StartTime:          testTime,
    EndTime:            testTime,
    Resolution:         FiveMinuteResolution,
    BaseAssetType:      AssetTypeNative,
    CounterAssetType:   AssetType4,
    CounterAssetCode:   "SLT",
    CounterAssetIssuer: "GCKA6K5PCQ6PNF5RQBF7PQDJWRHO6UOGFMRLK3DYHDOI244V47XKQ4GP",
    Order:              OrderDesc,
}
tradeAggs, err := client.TradeAggregations(ta)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(tradeAggs)

func (*Client) Trades Uses

func (c *Client) Trades(request TradeRequest) (tds hProtocol.TradesPage, err error)

Trades returns stellar trades (https://www.stellar.org/developers/horizon/reference/resources/trade.html) It can be used to return trades for an account, an offer and all trades on the network.

Code:


client := DefaultPublicNetClient
// Find all trades
tr := TradeRequest{Cursor: "123456", Limit: 30, Order: OrderAsc}
trades, err := client.Trades(tr)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(trades)

func (*Client) TransactionDetail Uses

func (c *Client) TransactionDetail(txHash string) (tx hProtocol.Transaction, err error)

TransactionDetail returns information about a particular transaction for a given transaction hash See https://www.stellar.org/developers/horizon/reference/endpoints/transactions-single.html

func (*Client) Transactions Uses

func (c *Client) Transactions(request TransactionRequest) (txs hProtocol.TransactionsPage, err error)

Transactions returns stellar transactions (https://www.stellar.org/developers/horizon/reference/resources/transaction.html) It can be used to return transactions for an account, a ledger,and all transactions on the network.

Code:


client := DefaultPublicNetClient
// transactions for an account
txRequest := TransactionRequest{ForAccount: "GCLWGQPMKXQSPF776IU33AH4PZNOOWNAWGGKVTBQMIC5IMKUNP3E6NVU"}
txs, err := client.Transactions(txRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(txs)

// all transactions
txRequest = TransactionRequest{Cursor: "now", Order: OrderDesc}
txs, err = client.Transactions(txRequest)
if err != nil {
    fmt.Println(err)
    return
}
fmt.Print(txs)
records := txs.Embedded.Records

for _, tx := range records {
    fmt.Print(tx)
}

func (*Client) Version Uses

func (c *Client) Version() string

Version returns the current version.

type ClientInterface Uses

type ClientInterface interface {
    AccountDetail(request AccountRequest) (hProtocol.Account, error)
    AccountData(request AccountRequest) (hProtocol.AccountData, error)
    Effects(request EffectRequest) (effects.EffectsPage, error)
    Assets(request AssetRequest) (hProtocol.AssetsPage, error)
    Ledgers(request LedgerRequest) (hProtocol.LedgersPage, error)
    LedgerDetail(sequence uint32) (hProtocol.Ledger, error)
    Metrics() (hProtocol.Metrics, error)
    FeeStats() (hProtocol.FeeStats, error)
    Offers(request OfferRequest) (hProtocol.OffersPage, error)
    Operations(request OperationRequest) (operations.OperationsPage, error)
    OperationDetail(id string) (operations.Operation, error)
    SubmitTransactionXDR(transactionXdr string) (hProtocol.TransactionSuccess, error)
    SubmitTransaction(transactionXdr txnbuild.Transaction) (hProtocol.TransactionSuccess, error)
    Transactions(request TransactionRequest) (hProtocol.TransactionsPage, error)
    TransactionDetail(txHash string) (hProtocol.Transaction, error)
    OrderBook(request OrderBookRequest) (hProtocol.OrderBookSummary, error)
    Paths(request PathsRequest) (hProtocol.PathsPage, error)
    Payments(request OperationRequest) (operations.OperationsPage, error)
    TradeAggregations(request TradeAggregationRequest) (hProtocol.TradeAggregationsPage, error)
    Trades(request TradeRequest) (hProtocol.TradesPage, error)
    Fund(addr string) (hProtocol.TransactionSuccess, error)
    StreamTransactions(ctx context.Context, request TransactionRequest, handler TransactionHandler) error
    StreamTrades(ctx context.Context, request TradeRequest, handler TradeHandler) error
    StreamEffects(ctx context.Context, request EffectRequest, handler EffectHandler) error
    StreamOperations(ctx context.Context, request OperationRequest, handler OperationHandler) error
    StreamPayments(ctx context.Context, request OperationRequest, handler OperationHandler) error
    StreamOffers(ctx context.Context, request OfferRequest, handler OfferHandler) error
    StreamLedgers(ctx context.Context, request LedgerRequest, handler LedgerHandler) error
    StreamOrderBooks(ctx context.Context, request OrderBookRequest, handler OrderBookHandler) error
    Root() (hProtocol.Root, error)
    NextAssetsPage(hProtocol.AssetsPage) (hProtocol.AssetsPage, error)
    PrevAssetsPage(hProtocol.AssetsPage) (hProtocol.AssetsPage, error)
    NextLedgersPage(hProtocol.LedgersPage) (hProtocol.LedgersPage, error)
    PrevLedgersPage(hProtocol.LedgersPage) (hProtocol.LedgersPage, error)
    NextEffectsPage(effects.EffectsPage) (effects.EffectsPage, error)
    PrevEffectsPage(effects.EffectsPage) (effects.EffectsPage, error)
    NextTransactionsPage(hProtocol.TransactionsPage) (hProtocol.TransactionsPage, error)
    PrevTransactionsPage(hProtocol.TransactionsPage) (hProtocol.TransactionsPage, error)
    NextOperationsPage(operations.OperationsPage) (operations.OperationsPage, error)
    PrevOperationsPage(operations.OperationsPage) (operations.OperationsPage, error)
    NextPaymentsPage(operations.OperationsPage) (operations.OperationsPage, error)
    PrevPaymentsPage(operations.OperationsPage) (operations.OperationsPage, error)
    NextOffersPage(hProtocol.OffersPage) (hProtocol.OffersPage, error)
    PrevOffersPage(hProtocol.OffersPage) (hProtocol.OffersPage, error)
    NextTradesPage(hProtocol.TradesPage) (hProtocol.TradesPage, error)
    PrevTradesPage(hProtocol.TradesPage) (hProtocol.TradesPage, error)
    HomeDomainForAccount(aid string) (string, error)
    NextTradeAggregationsPage(hProtocol.TradeAggregationsPage) (hProtocol.TradeAggregationsPage, error)
    PrevTradeAggregationsPage(hProtocol.TradeAggregationsPage) (hProtocol.TradeAggregationsPage, error)
}

ClientInterface contains methods implemented by the horizon client

type EffectHandler Uses

type EffectHandler func(effects.Effect)

EffectHandler is a function that is called when a new effect is received

type EffectRequest Uses

type EffectRequest struct {
    ForAccount     string
    ForLedger      string
    ForOperation   string
    ForTransaction string
    Order          Order
    Cursor         string
    Limit          uint
}

EffectRequest struct contains data for getting effects from a horizon server. "ForAccount", "ForLedger", "ForOperation" and "ForTransaction": Not more than one of these

can be set at a time. If none are set, the default is to return all effects.

The query parameters (Order, Cursor and Limit) are optional. All or none can be set.

func (EffectRequest) BuildURL Uses

func (er EffectRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the EffectRequest struct. If no data is set, it defaults to the build the URL for all effects

func (EffectRequest) StreamEffects Uses

func (er EffectRequest) StreamEffects(ctx context.Context, client *Client, handler EffectHandler) error

StreamEffects streams horizon effects. It can be used to stream all effects or account specific effects. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. EffectHandler is a user-supplied function that is executed for each streamed effect received.

type Error Uses

type Error struct {
    Response *http.Response
    Problem  problem.P
}

Error struct contains the problem returned by Horizon

func (*Error) Envelope Uses

func (herr *Error) Envelope() (*xdr.TransactionEnvelope, error)

Envelope extracts the transaction envelope that triggered this error from the extra fields.

func (*Error) EnvelopeXDR Uses

func (herr *Error) EnvelopeXDR() (string, error)

EnvelopeXDR returns the base 64 serialised string representation of the XDR envelope. This can be stored, or decoded in the Stellar Laboratory XDR viewer for example.

func (Error) Error Uses

func (herr Error) Error() string

func (*Error) ResultCodes Uses

func (herr *Error) ResultCodes() (*hProtocol.TransactionResultCodes, error)

ResultCodes extracts a result code summary from the error, if possible.

func (*Error) ResultString Uses

func (herr *Error) ResultString() (string, error)

ResultString extracts the transaction result as a string.

type HTTP Uses

type HTTP interface {
    Do(req *http.Request) (resp *http.Response, err error)
    Get(url string) (resp *http.Response, err error)
    PostForm(url string, data url.Values) (resp *http.Response, err error)
}

HTTP represents the HTTP client that a horizon client uses to communicate

type HorizonRequest Uses

type HorizonRequest interface {
    BuildURL() (string, error)
}

HorizonRequest contains methods implemented by request structs for horizon endpoints.

type LedgerHandler Uses

type LedgerHandler func(hProtocol.Ledger)

LedgerHandler is a function that is called when a new ledger is received

type LedgerRequest Uses

type LedgerRequest struct {
    Order  Order
    Cursor string
    Limit  uint
    // contains filtered or unexported fields
}

LedgerRequest struct contains data for getting ledger details from a horizon server. The query parameters (Order, Cursor and Limit) are optional. All or none can be set.

func (LedgerRequest) BuildURL Uses

func (lr LedgerRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the LedgerRequest struct. If no data is set, it defaults to the build the URL for all ledgers

func (LedgerRequest) StreamLedgers Uses

func (lr LedgerRequest) StreamLedgers(ctx context.Context, client *Client,
    handler LedgerHandler) (err error)

StreamLedgers streams stellar ledgers. It can be used to stream all ledgers. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. LedgerHandler is a user-supplied function that is executed for each streamed ledger received.

type MockClient Uses

type MockClient struct {
    mock.Mock
}

MockClient is a mockable horizon client.

func (*MockClient) AccountData Uses

func (m *MockClient) AccountData(request AccountRequest) (hProtocol.AccountData, error)

AccountData is a mocking method

func (*MockClient) AccountDetail Uses

func (m *MockClient) AccountDetail(request AccountRequest) (hProtocol.Account, error)

AccountDetail is a mocking method

func (*MockClient) Assets Uses

func (m *MockClient) Assets(request AssetRequest) (hProtocol.AssetsPage, error)

Assets is a mocking method

func (*MockClient) Effects Uses

func (m *MockClient) Effects(request EffectRequest) (effects.EffectsPage, error)

Effects is a mocking method

func (*MockClient) FeeStats Uses

func (m *MockClient) FeeStats() (hProtocol.FeeStats, error)

FeeStats is a mocking method

func (*MockClient) Fund Uses

func (m *MockClient) Fund(addr string) (hProtocol.TransactionSuccess, error)

Fund is a mocking method

func (*MockClient) HomeDomainForAccount Uses

func (m *MockClient) HomeDomainForAccount(aid string) (string, error)

HomeDomainForAccount is a mocking method

func (*MockClient) LedgerDetail Uses

func (m *MockClient) LedgerDetail(sequence uint32) (hProtocol.Ledger, error)

LedgerDetail is a mocking method

func (*MockClient) Ledgers Uses

func (m *MockClient) Ledgers(request LedgerRequest) (hProtocol.LedgersPage, error)

Ledgers is a mocking method

func (*MockClient) Metrics Uses

func (m *MockClient) Metrics() (hProtocol.Metrics, error)

Metrics is a mocking method

func (*MockClient) NextAssetsPage Uses

func (m *MockClient) NextAssetsPage(page hProtocol.AssetsPage) (hProtocol.AssetsPage, error)

NextAssetsPage is a mocking method

func (*MockClient) NextEffectsPage Uses

func (m *MockClient) NextEffectsPage(page effects.EffectsPage) (effects.EffectsPage, error)

NextEffectsPage is a mocking method

func (*MockClient) NextLedgersPage Uses

func (m *MockClient) NextLedgersPage(page hProtocol.LedgersPage) (hProtocol.LedgersPage, error)

NextLedgersPage is a mocking method

func (*MockClient) NextOffersPage Uses

func (m *MockClient) NextOffersPage(page hProtocol.OffersPage) (hProtocol.OffersPage, error)

NextOffersPage is a mocking method

func (*MockClient) NextOperationsPage Uses

func (m *MockClient) NextOperationsPage(page operations.OperationsPage) (operations.OperationsPage, error)

NextOperationsPage is a mocking method

func (*MockClient) NextPaymentsPage Uses

func (m *MockClient) NextPaymentsPage(page operations.OperationsPage) (operations.OperationsPage, error)

NextPaymentsPage is a mocking method

func (*MockClient) NextTradeAggregationsPage Uses

func (m *MockClient) NextTradeAggregationsPage(page hProtocol.TradeAggregationsPage) (hProtocol.TradeAggregationsPage, error)

NextTradeAggregationsPage is a mocking method

func (*MockClient) NextTradesPage Uses

func (m *MockClient) NextTradesPage(page hProtocol.TradesPage) (hProtocol.TradesPage, error)

NextTradesPage is a mocking method

func (*MockClient) NextTransactionsPage Uses

func (m *MockClient) NextTransactionsPage(page hProtocol.TransactionsPage) (hProtocol.TransactionsPage, error)

NextTransactionsPage is a mocking method

func (*MockClient) Offers Uses

func (m *MockClient) Offers(request OfferRequest) (hProtocol.OffersPage, error)

Offers is a mocking method

func (*MockClient) OperationDetail Uses

func (m *MockClient) OperationDetail(id string) (operations.Operation, error)

OperationDetail is a mocking method

func (*MockClient) Operations Uses

func (m *MockClient) Operations(request OperationRequest) (operations.OperationsPage, error)

Operations is a mocking method

func (*MockClient) OrderBook Uses

func (m *MockClient) OrderBook(request OrderBookRequest) (hProtocol.OrderBookSummary, error)

OrderBook is a mocking method

func (*MockClient) Paths Uses

func (m *MockClient) Paths(request PathsRequest) (hProtocol.PathsPage, error)

Paths is a mocking method

func (*MockClient) Payments Uses

func (m *MockClient) Payments(request OperationRequest) (operations.OperationsPage, error)

Payments is a mocking method

func (*MockClient) PrevAssetsPage Uses

func (m *MockClient) PrevAssetsPage(page hProtocol.AssetsPage) (hProtocol.AssetsPage, error)

PrevAssetsPage is a mocking method

func (*MockClient) PrevEffectsPage Uses

func (m *MockClient) PrevEffectsPage(page effects.EffectsPage) (effects.EffectsPage, error)

PrevEffectsPage is a mocking method

func (*MockClient) PrevLedgersPage Uses

func (m *MockClient) PrevLedgersPage(page hProtocol.LedgersPage) (hProtocol.LedgersPage, error)

PrevLedgersPage is a mocking method

func (*MockClient) PrevOffersPage Uses

func (m *MockClient) PrevOffersPage(page hProtocol.OffersPage) (hProtocol.OffersPage, error)

PrevOffersPage is a mocking method

func (*MockClient) PrevOperationsPage Uses

func (m *MockClient) PrevOperationsPage(page operations.OperationsPage) (operations.OperationsPage, error)

PrevOperationsPage is a mocking method

func (*MockClient) PrevPaymentsPage Uses

func (m *MockClient) PrevPaymentsPage(page operations.OperationsPage) (operations.OperationsPage, error)

PrevPaymentsPage is a mocking method

func (*MockClient) PrevTradeAggregationsPage Uses

func (m *MockClient) PrevTradeAggregationsPage(page hProtocol.TradeAggregationsPage) (hProtocol.TradeAggregationsPage, error)

PrevTradeAggregationsPage is a mocking method

func (*MockClient) PrevTradesPage Uses

func (m *MockClient) PrevTradesPage(page hProtocol.TradesPage) (hProtocol.TradesPage, error)

PrevTradesPage is a mocking method

func (*MockClient) PrevTransactionsPage Uses

func (m *MockClient) PrevTransactionsPage(page hProtocol.TransactionsPage) (hProtocol.TransactionsPage, error)

PrevTransactionsPage is a mocking method

func (*MockClient) Root Uses

func (m *MockClient) Root() (hProtocol.Root, error)

Root is a mocking method

func (*MockClient) StreamEffects Uses

func (m *MockClient) StreamEffects(ctx context.Context, request EffectRequest, handler EffectHandler) error

StreamEffects is a mocking method

func (*MockClient) StreamLedgers Uses

func (m *MockClient) StreamLedgers(ctx context.Context, request LedgerRequest, handler LedgerHandler) error

StreamLedgers is a mocking method

func (*MockClient) StreamOffers Uses

func (m *MockClient) StreamOffers(ctx context.Context, request OfferRequest, handler OfferHandler) error

StreamOffers is a mocking method

func (*MockClient) StreamOperations Uses

func (m *MockClient) StreamOperations(ctx context.Context, request OperationRequest, handler OperationHandler) error

StreamOperations is a mocking method

func (*MockClient) StreamOrderBooks Uses

func (m *MockClient) StreamOrderBooks(ctx context.Context, request OrderBookRequest, handler OrderBookHandler) error

StreamOrderBooks is a mocking method

func (*MockClient) StreamPayments Uses

func (m *MockClient) StreamPayments(ctx context.Context, request OperationRequest, handler OperationHandler) error

StreamPayments is a mocking method

func (*MockClient) StreamTrades Uses

func (m *MockClient) StreamTrades(ctx context.Context, request TradeRequest, handler TradeHandler) error

StreamTrades is a mocking method

func (*MockClient) StreamTransactions Uses

func (m *MockClient) StreamTransactions(ctx context.Context, request TransactionRequest, handler TransactionHandler) error

StreamTransactions is a mocking method

func (*MockClient) SubmitTransaction Uses

func (m *MockClient) SubmitTransaction(transaction txnbuild.Transaction) (hProtocol.TransactionSuccess, error)

SubmitTransaction is a mocking method

func (*MockClient) SubmitTransactionXDR Uses

func (m *MockClient) SubmitTransactionXDR(transactionXdr string) (hProtocol.TransactionSuccess, error)

SubmitTransactionXDR is a mocking method

func (*MockClient) TradeAggregations Uses

func (m *MockClient) TradeAggregations(request TradeAggregationRequest) (hProtocol.TradeAggregationsPage, error)

TradeAggregations is a mocking method

func (*MockClient) Trades Uses

func (m *MockClient) Trades(request TradeRequest) (hProtocol.TradesPage, error)

Trades is a mocking method

func (*MockClient) TransactionDetail Uses

func (m *MockClient) TransactionDetail(txHash string) (hProtocol.Transaction, error)

TransactionDetail is a mocking method

func (*MockClient) Transactions Uses

func (m *MockClient) Transactions(request TransactionRequest) (hProtocol.TransactionsPage, error)

Transactions is a mocking method

type OfferHandler Uses

type OfferHandler func(hProtocol.Offer)

OfferHandler is a function that is called when a new offer is received

type OfferRequest Uses

type OfferRequest struct {
    ForAccount string
    Order      Order
    Cursor     string
    Limit      uint
}

OfferRequest struct contains data for getting offers made by an account from a horizon server. "ForAccount" is required. The query parameters (Order, Cursor and Limit) are optional. All or none can be set.

func (OfferRequest) BuildURL Uses

func (or OfferRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the OfferRequest struct.

func (OfferRequest) StreamOffers Uses

func (or OfferRequest) StreamOffers(ctx context.Context, client *Client, handler OfferHandler) (err error)

StreamOffers streams offers processed by the Stellar network for an account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OfferHandler is a user-supplied function that is executed for each streamed offer received.

type OperationHandler Uses

type OperationHandler func(operations.Operation)

OperationHandler is a function that is called when a new operation is received

type OperationRequest Uses

type OperationRequest struct {
    ForAccount     string
    ForLedger      uint
    ForTransaction string

    Order         Order
    Cursor        string
    Limit         uint
    IncludeFailed bool
    Join          string
    // contains filtered or unexported fields
}

OperationRequest struct contains data for getting operation details from a horizon server. "ForAccount", "ForLedger", "ForTransaction": Only one of these can be set at a time. If none are provided, the default is to return all operations. The query parameters (Order, Cursor, Limit and IncludeFailed) are optional. All or none can be set.

func (OperationRequest) BuildURL Uses

func (op OperationRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the OperationRequest struct. If no data is set, it defaults to the build the URL for all operations or all payments; depending on thevalue of `op.endpoint`

func (*OperationRequest) SetOperationsEndpoint Uses

func (op *OperationRequest) SetOperationsEndpoint() *OperationRequest

SetOperationsEndpoint is a helper function that sets the `endpoint` for OperationRequests to `operations`

func (*OperationRequest) SetPaymentsEndpoint Uses

func (op *OperationRequest) SetPaymentsEndpoint() *OperationRequest

SetPaymentsEndpoint is a helper function that sets the `endpoint` for OperationRequests to `payments`

func (OperationRequest) StreamOperations Uses

func (op OperationRequest) StreamOperations(ctx context.Context, client *Client, handler OperationHandler) error

StreamOperations streams stellar operations. It can be used to stream all operations or operations for and account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OperationHandler is a user-supplied function that is executed for each streamed

operation received.

type Order Uses

type Order string

Order represents `order` param in queries

type OrderBookHandler Uses

type OrderBookHandler func(hProtocol.OrderBookSummary)

OrderBookHandler is a function that is called when a new order summary is received

type OrderBookRequest Uses

type OrderBookRequest struct {
    SellingAssetType   AssetType
    SellingAssetCode   string
    SellingAssetIssuer string
    BuyingAssetType    AssetType
    BuyingAssetCode    string
    BuyingAssetIssuer  string
    Limit              uint
}

OrderBookRequest struct contains data for getting the orderbook for an asset pair from a horizon server. Limit is optional. All other parameters are required.

func (OrderBookRequest) BuildURL Uses

func (obr OrderBookRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the OrderBookRequest struct.

func (OrderBookRequest) StreamOrderBooks Uses

func (obr OrderBookRequest) StreamOrderBooks(ctx context.Context, client *Client, handler OrderBookHandler) error

StreamOrderBooks streams the orderbook for a given asset pair. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. OrderBookHandler is a user-supplied function that is executed for each streamed order received.

type PathsRequest Uses

type PathsRequest struct {
    DestinationAccount     string
    DestinationAssetType   AssetType
    DestinationAssetCode   string
    DestinationAssetIssuer string
    DestinationAmount      string
    SourceAccount          string
}

PathsRequest struct contains data for getting available payment paths from a horizon server. All parameters are required.

func (PathsRequest) BuildURL Uses

func (pr PathsRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the PathsRequest struct.

type ServerTimeRecord Uses

type ServerTimeRecord struct {
    ServerTime        int64
    LocalTimeRecorded int64
}

ServerTimeRecord contains data for the current unix time of a horizon server instance, and the local time when it was recorded.

type TradeAggregationRequest Uses

type TradeAggregationRequest struct {
    StartTime          time.Time
    EndTime            time.Time
    Resolution         time.Duration
    Offset             time.Duration
    BaseAssetType      AssetType
    BaseAssetCode      string
    BaseAssetIssuer    string
    CounterAssetType   AssetType
    CounterAssetCode   string
    CounterAssetIssuer string
    Order              Order
    Limit              uint
}

TradeAggregationRequest struct contains data for getting trade aggregations from a horizon server. The query parameters (Order and Limit) are optional. All or none can be set. All other parameters are required.

func (TradeAggregationRequest) BuildURL Uses

func (ta TradeAggregationRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the TradeAggregationRequest struct.

type TradeHandler Uses

type TradeHandler func(hProtocol.Trade)

TradeHandler is a function that is called when a new trade is received

type TradeRequest Uses

type TradeRequest struct {
    ForOfferID         string
    ForAccount         string
    BaseAssetType      AssetType
    BaseAssetCode      string
    BaseAssetIssuer    string
    CounterAssetType   AssetType
    CounterAssetCode   string
    CounterAssetIssuer string
    Order              Order
    Cursor             string
    Limit              uint
}

TradeRequest struct contains data for getting trade details from a horizon server. "ForAccount", "ForOfferID": Only one of these can be set at a time. If none are provided, the default is to return all trades. All other query parameters are optional. All or none can be set.

func (TradeRequest) BuildURL Uses

func (tr TradeRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the TradeRequest struct. If no data is set, it defaults to the build the URL for all trades

func (TradeRequest) StreamTrades Uses

func (tr TradeRequest) StreamTrades(ctx context.Context, client *Client,
    handler TradeHandler) (err error)

StreamTrades streams executed trades. It can be used to stream all trades, trades for an account and trades for an offer. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. TradeHandler is a user-supplied function that is executed for each streamed trade received.

type TransactionHandler Uses

type TransactionHandler func(hProtocol.Transaction)

TransactionHandler is a function that is called when a new transaction is received

type TransactionRequest Uses

type TransactionRequest struct {
    ForAccount string
    ForLedger  uint

    Order         Order
    Cursor        string
    Limit         uint
    IncludeFailed bool
    // contains filtered or unexported fields
}

TransactionRequest struct contains data for getting transaction details from a horizon server. "ForAccount", "ForLedger": Only one of these can be set at a time. If none are provided, the default is to return all transactions. The query parameters (Order, Cursor, Limit and IncludeFailed) are optional. All or none can be set.

func (TransactionRequest) BuildURL Uses

func (tr TransactionRequest) BuildURL() (endpoint string, err error)

BuildURL creates the endpoint to be queried based on the data in the TransactionRequest struct. If no data is set, it defaults to the build the URL for all transactions

func (TransactionRequest) StreamTransactions Uses

func (tr TransactionRequest) StreamTransactions(ctx context.Context, client *Client,
    handler TransactionHandler) (err error)

StreamTransactions streams executed transactions. It can be used to stream all transactions and transactions for an account. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. TransactionHandler is a user-supplied function that is executed for each streamed transaction received.

type UniversalTimeHandler Uses

type UniversalTimeHandler func() int64

UniversalTimeHandler is a function that is called to return the UTC unix time in seconds. This handler is used when getting the time from a horizon server, which can be used to calculate transaction timebounds.

Package horizonclient imports 22 packages (graph) and is imported by 40 packages. Updated 2019-09-13. Refresh now. Tools for package owners.