README

horizon

This package is deprecated use: horizonclient instead

Expand ▾ Collapse ▴

Documentation

Overview

    Package horizon is DEPRECATED in favour of clients/horizonclient! It used to provide client access to a horizon server, allowing an application to post transactions and lookup ledger information.

    Deprecated: clients/horizon package with all its exported methods and variables will no longer be maintained. It will be removed in future versions of the SDK. Use clients/horizonclient (https://godoc.org/github.com/stellar/go/clients/horizonclient) instead.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    View Source
    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")
    )
    View Source
    var DefaultPublicNetClient = &Client{
    	URL:  "https://horizon.stellar.org",
    	HTTP: http.DefaultClient,
    }

      DefaultPublicNetClient is a default client to connect to public network

      View Source
      var DefaultTestNetClient = &Client{
      	URL:  "https://horizon-testnet.stellar.org",
      	HTTP: http.DefaultClient,
      }

        DefaultTestNetClient is a default client to connect to test network

        Functions

        This section is empty.

        Types

        type Account

        type Account = hProtocol.Account

          Deprecated: use protocols/horizon instead

          type AccountFlags

          type AccountFlags = hProtocol.AccountFlags

            Deprecated: use protocols/horizon instead

            type AccountThresholds

            type AccountThresholds = hProtocol.AccountThresholds

              Deprecated: use protocols/horizon instead

              type Asset

              type Asset = hProtocol.Asset

                Deprecated: use protocols/horizon instead

                type At

                type At string

                  At is a paging parameter that can be used to override the URL loaded in a remote method call to horizon.

                  type Balance

                  type Balance = hProtocol.Balance

                    Deprecated: use protocols/horizon instead

                    type Client

                    type Client struct {
                    	// URL of Horizon server to connect
                    	URL string
                    
                    	// HTTP client to make requests with
                    	HTTP HTTP
                    
                    	AppName    string
                    	AppVersion string
                    	// contains filtered or unexported fields
                    }

                      Client struct contains data required to connect to Horizon instance It is okay to call methods on Client concurrently. A Client must not be copied after first use.

                      func (*Client) HomeDomainForAccount

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

                        HomeDomainForAccount returns the home domain for the provided strkey-encoded account id. Deprecated: use clients/horizonclient instead

                        func (*Client) LoadAccount

                        func (c *Client) LoadAccount(accountID string) (account Account, err error)

                          LoadAccount loads the account state from horizon. err can be either error object or horizon.Error object. Deprecated: use horizonclient.AccountDetail instead

                          func (*Client) LoadAccountMergeAmount

                          func (c *Client) LoadAccountMergeAmount(p *Payment) error

                            LoadAccountMergeAmount loads `account_merge` operation amount from it's effects Deprecated: use clients/horizonclient instead

                            func (*Client) LoadAccountOffers

                            func (c *Client) LoadAccountOffers(
                            	accountID string,
                            	params ...interface{},
                            ) (offers OffersPage, err error)

                              LoadAccountOffers loads the account offers from horizon. err can be either error object or horizon.Error object. Deprecated: use horizonclient.Offers instead

                              func (*Client) LoadAccountTransactions

                              func (c *Client) LoadAccountTransactions(accountID string, params ...interface{}) (TransactionsPage, error)

                                Deprecated: use horizonclient.Transactions instead

                                func (*Client) LoadMemo

                                func (c *Client) LoadMemo(p *Payment) (err error)

                                  LoadMemo loads memo for a transaction in Payment Deprecated: use clients/horizonclient instead

                                  func (*Client) LoadOperation

                                  func (c *Client) LoadOperation(operationID string) (payment Payment, err error)

                                    LoadOperation loads a single operation from Horizon server Deprecated: use horizonclient.OperationDetail instead

                                    func (*Client) LoadOrderBook

                                    func (c *Client) LoadOrderBook(
                                    	selling Asset,
                                    	buying Asset,
                                    	params ...interface{},
                                    ) (orderBook OrderBookSummary, err error)

                                      LoadOrderBook loads order book for given selling and buying assets. Deprecated: use horizonclient.OrderBook instead

                                      func (*Client) LoadTradeAggregations

                                      func (c *Client) LoadTradeAggregations(
                                      	baseAsset Asset,
                                      	counterAsset Asset,
                                      	resolution int64,
                                      	params ...interface{},
                                      ) (tradeAggrs TradeAggregationsPage, err error)

                                        LoadTradeAggregations loads the trade aggregation from horizon. Deprecated: use horizonclient.TradeAggregations instead

                                        func (*Client) LoadTrades

                                        func (c *Client) LoadTrades(
                                        	baseAsset Asset,
                                        	counterAsset Asset,
                                        	offerID int64,
                                        	resolution int64,
                                        	params ...interface{},
                                        ) (tradesPage TradesPage, err error)

                                          LoadTrades loads the /trades endpoint from horizon. Deprecated: use horizonclient.Trades instead

                                          func (*Client) LoadTransaction

                                          func (c *Client) LoadTransaction(transactionID string) (transaction Transaction, err error)

                                            LoadTransaction loads a single transaction from Horizon server Deprecated: use horizonclient.TransactionDetail instead

                                            func (*Client) Root

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

                                              Root loads the root endpoint of horizon Deprecated: use clients/horizonclient instead

                                              func (*Client) SequenceForAccount

                                              func (c *Client) SequenceForAccount(
                                              	accountID string,
                                              ) (xdr.SequenceNumber, error)

                                                SequenceForAccount implements build.SequenceProvider Deprecated: use clients/horizonclient instead

                                                func (*Client) StreamLedgers

                                                func (c *Client) StreamLedgers(
                                                	ctx context.Context,
                                                	cursor *Cursor,
                                                	handler LedgerHandler,
                                                ) (err error)

                                                  StreamLedgers streams incoming ledgers. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. Deprecated: use horizonclient.StreamLedgers instead

                                                  Example
                                                  Output:
                                                  
                                                  

                                                  func (*Client) StreamPayments

                                                  func (c *Client) StreamPayments(
                                                  	ctx context.Context,
                                                  	accountID string,
                                                  	cursor *Cursor,
                                                  	handler PaymentHandler,
                                                  ) (err error)

                                                    StreamPayments streams payments, for which the given `accountID` was either the sender or receiver. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. Deprecated: use horizonclient.StreamPayments instead

                                                    func (*Client) StreamTransactions

                                                    func (c *Client) StreamTransactions(
                                                    	ctx context.Context,
                                                    	accountID string,
                                                    	cursor *Cursor,
                                                    	handler TransactionHandler,
                                                    ) (err error)

                                                      StreamTransactions streams incoming transactions. Use context.WithCancel to stop streaming or context.Background() if you want to stream indefinitely. Deprecated: use horizonclient.StreamTransactions instead

                                                      func (*Client) SubmitTransaction

                                                      func (c *Client) SubmitTransaction(
                                                      	transactionEnvelopeXdr string,
                                                      ) (response TransactionSuccess, err error)

                                                        SubmitTransaction submits a transaction to the network. err can be either error object or horizon.Error object. Deprecated: use horizonclient.SubmitTransactionXDR instead

                                                        Example
                                                        Output:
                                                        
                                                        

                                                        type ClientInterface

                                                        type ClientInterface interface {
                                                        	Root() (Root, error)
                                                        	HomeDomainForAccount(aid string) (string, error)
                                                        	LoadAccount(accountID string) (Account, error)
                                                        	LoadAccountOffers(accountID string, params ...interface{}) (offers OffersPage, err error)
                                                        	LoadTradeAggregations(
                                                        		baseAsset Asset,
                                                        		counterAsset Asset,
                                                        		resolution int64,
                                                        		params ...interface{},
                                                        	) (tradeAggrs TradeAggregationsPage, err error)
                                                        	LoadTrades(
                                                        		baseAsset Asset,
                                                        		counterAsset Asset,
                                                        		offerID int64,
                                                        		resolution int64,
                                                        		params ...interface{},
                                                        	) (tradesPage TradesPage, err error)
                                                        	LoadAccountMergeAmount(p *Payment) error
                                                        	LoadMemo(p *Payment) error
                                                        	LoadOperation(operationID string) (payment Payment, err error)
                                                        	LoadOrderBook(selling Asset, buying Asset, params ...interface{}) (orderBook OrderBookSummary, err error)
                                                        	LoadTransaction(transactionID string) (transaction Transaction, err error)
                                                        	LoadAccountTransactions(transactionID string, params ...interface{}) (transactions TransactionsPage, err error)
                                                        	SequenceForAccount(accountID string) (xdr.SequenceNumber, error)
                                                        	StreamLedgers(ctx context.Context, cursor *Cursor, handler LedgerHandler) error
                                                        	StreamPayments(ctx context.Context, accountID string, cursor *Cursor, handler PaymentHandler) error
                                                        	StreamTransactions(ctx context.Context, accountID string, cursor *Cursor, handler TransactionHandler) error
                                                        	SubmitTransaction(txeBase64 string) (TransactionSuccess, error)
                                                        }

                                                        type Cursor

                                                        type Cursor string

                                                          Cursor represents `cursor` param in queries

                                                          type Effect

                                                          type Effect struct {
                                                          	Type   string `json:"type"`
                                                          	Amount string `json:"amount"`
                                                          }

                                                            EffectResponse contains effect data returned by Horizon. Currently used by LoadAccountMergeAmount only.

                                                            type EffectsPage

                                                            type EffectsPage struct {
                                                            	Embedded struct {
                                                            		Records []Effect
                                                            	} `json:"_embedded"`
                                                            }

                                                              EffectsPageResponse contains page of effects returned by Horizon. Currently used by LoadAccountMergeAmount only.

                                                              type EndTime

                                                              type EndTime int64

                                                                EndTime is an integer values of timestamp

                                                                type Error

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

                                                                  Error struct contains the problem returned by Horizon

                                                                  func (*Error) Envelope

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

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

                                                                    func (Error) Error

                                                                    func (herr Error) Error() string

                                                                    func (*Error) ResultCodes

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

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

                                                                      func (*Error) ResultString

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

                                                                        ResultString extracts the transaction result as a string.

                                                                        type HTTP

                                                                        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 Ledger

                                                                          type Ledger = hProtocol.Ledger

                                                                            Deprecated: use protocols/horizon instead

                                                                            type LedgerHandler

                                                                            type LedgerHandler func(Ledger)

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

                                                                              type Limit

                                                                              type Limit uint

                                                                                Limit represents `limit` param in queries

                                                                                type Link = hal.Link

                                                                                  Deprecated: use render/hal instead

                                                                                  type MockClient

                                                                                  type MockClient struct {
                                                                                  	mock.Mock
                                                                                  }

                                                                                    MockClient is a mockable horizon client.

                                                                                    func (*MockClient) HomeDomainForAccount

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

                                                                                      HomeDomainForAccount is a mocking a method

                                                                                      func (*MockClient) LoadAccount

                                                                                      func (m *MockClient) LoadAccount(accountID string) (Account, error)

                                                                                        LoadAccount is a mocking a method

                                                                                        func (*MockClient) LoadAccountMergeAmount

                                                                                        func (m *MockClient) LoadAccountMergeAmount(p *Payment) error

                                                                                          LoadAccountMergeAmount is a mocking a method

                                                                                          func (*MockClient) LoadAccountOffers

                                                                                          func (m *MockClient) LoadAccountOffers(
                                                                                          	accountID string,
                                                                                          	params ...interface{},
                                                                                          ) (offers OffersPage, err error)

                                                                                            LoadAccountOffers is a mocking a method

                                                                                            func (*MockClient) LoadAccountTransactions

                                                                                            func (m *MockClient) LoadAccountTransactions(accountId string, params ...interface{}) (transactionPage TransactionsPage, err error)

                                                                                              LoadAccountTransactions is a mocking a method

                                                                                              func (*MockClient) LoadMemo

                                                                                              func (m *MockClient) LoadMemo(p *Payment) error

                                                                                                LoadMemo is a mocking a method

                                                                                                func (*MockClient) LoadOperation

                                                                                                func (m *MockClient) LoadOperation(operationID string) (payment Payment, err error)

                                                                                                  LoadMemo is a mocking a method

                                                                                                  func (*MockClient) LoadOrderBook

                                                                                                  func (m *MockClient) LoadOrderBook(
                                                                                                  	selling Asset,
                                                                                                  	buying Asset,
                                                                                                  	params ...interface{},
                                                                                                  ) (orderBook OrderBookSummary, err error)

                                                                                                    LoadOrderBook is a mocking a method

                                                                                                    func (*MockClient) LoadTradeAggregations

                                                                                                    func (m *MockClient) LoadTradeAggregations(
                                                                                                    	baseAsset Asset,
                                                                                                    	counterAsset Asset,
                                                                                                    	resolution int64,
                                                                                                    	params ...interface{},
                                                                                                    ) (tradeAggrs TradeAggregationsPage, err error)

                                                                                                      LoadTradeAggregations is a mocking a method

                                                                                                      func (*MockClient) LoadTrades

                                                                                                      func (m *MockClient) LoadTrades(
                                                                                                      	baseAsset Asset,
                                                                                                      	counterAsset Asset,
                                                                                                      	offerID int64,
                                                                                                      	resolution int64,
                                                                                                      	params ...interface{},
                                                                                                      ) (tradesPage TradesPage, err error)

                                                                                                        LoadTrades is a mocking a method

                                                                                                        func (*MockClient) LoadTransaction

                                                                                                        func (m *MockClient) LoadTransaction(transactionID string) (transaction Transaction, err error)

                                                                                                          LoadTransaction is a mocking a method

                                                                                                          func (*MockClient) Root

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

                                                                                                            Root is a mocking a method

                                                                                                            func (*MockClient) SequenceForAccount

                                                                                                            func (m *MockClient) SequenceForAccount(accountID string) (xdr.SequenceNumber, error)

                                                                                                              SequenceForAccount is a mocking a method

                                                                                                              func (*MockClient) StreamLedgers

                                                                                                              func (m *MockClient) StreamLedgers(
                                                                                                              	ctx context.Context,
                                                                                                              	cursor *Cursor,
                                                                                                              	handler LedgerHandler,
                                                                                                              ) error

                                                                                                                StreamLedgers is a mocking a method

                                                                                                                func (*MockClient) StreamPayments

                                                                                                                func (m *MockClient) StreamPayments(
                                                                                                                	ctx context.Context,
                                                                                                                	accountID string,
                                                                                                                	cursor *Cursor,
                                                                                                                	handler PaymentHandler,
                                                                                                                ) error

                                                                                                                  StreamPayments is a mocking a method

                                                                                                                  func (*MockClient) StreamTransactions

                                                                                                                  func (m *MockClient) StreamTransactions(
                                                                                                                  	ctx context.Context,
                                                                                                                  	accountID string,
                                                                                                                  	cursor *Cursor,
                                                                                                                  	handler TransactionHandler,
                                                                                                                  ) error

                                                                                                                    StreamTransactions is a mocking a method

                                                                                                                    func (*MockClient) SubmitTransaction

                                                                                                                    func (m *MockClient) SubmitTransaction(
                                                                                                                    	txeBase64 string,
                                                                                                                    ) (TransactionSuccess, error)

                                                                                                                      SubmitTransaction is a mocking a method

                                                                                                                      type Offer

                                                                                                                      type Offer = hProtocol.Offer

                                                                                                                        Deprecated: use protocols/horizon instead

                                                                                                                        type OffersPage

                                                                                                                        type OffersPage struct {
                                                                                                                        	Links    hal.Links `json:"_links"`
                                                                                                                        	Embedded struct {
                                                                                                                        		Records []Offer `json:"records"`
                                                                                                                        	} `json:"_embedded"`
                                                                                                                        }

                                                                                                                          OffersPage returns a list of offers

                                                                                                                          type Order

                                                                                                                          type Order string

                                                                                                                            Order represents `order` param in queries

                                                                                                                            const (
                                                                                                                            	OrderAsc  Order = "asc"
                                                                                                                            	OrderDesc Order = "desc"
                                                                                                                            )

                                                                                                                            type OrderBookSummary

                                                                                                                            type OrderBookSummary = hProtocol.OrderBookSummary

                                                                                                                              Deprecated: use protocols/horizon instead

                                                                                                                              type Payment

                                                                                                                              type Payment struct {
                                                                                                                              	ID          string `json:"id"`
                                                                                                                              	Type        string `json:"type"`
                                                                                                                              	PagingToken string `json:"paging_token"`
                                                                                                                              
                                                                                                                              	Links struct {
                                                                                                                              		Effects struct {
                                                                                                                              			Href string `json:"href"`
                                                                                                                              		} `json:"effects"`
                                                                                                                              		Transaction struct {
                                                                                                                              			Href string `json:"href"`
                                                                                                                              		} `json:"transaction"`
                                                                                                                              	} `json:"_links"`
                                                                                                                              
                                                                                                                              	SourceAccount string `json:"source_account"`
                                                                                                                              	CreatedAt     string `json:"created_at"`
                                                                                                                              
                                                                                                                              	// create_account and account_merge field
                                                                                                                              	Account string `json:"account"`
                                                                                                                              
                                                                                                                              	// create_account fields
                                                                                                                              	Funder          string `json:"funder"`
                                                                                                                              	StartingBalance string `json:"starting_balance"`
                                                                                                                              
                                                                                                                              	// account_merge fields
                                                                                                                              	Into string `json:"into"`
                                                                                                                              
                                                                                                                              	// payment/path_payment fields
                                                                                                                              	From        string `json:"from"`
                                                                                                                              	To          string `json:"to"`
                                                                                                                              	AssetType   string `json:"asset_type"`
                                                                                                                              	AssetCode   string `json:"asset_code"`
                                                                                                                              	AssetIssuer string `json:"asset_issuer"`
                                                                                                                              	Amount      string `json:"amount"`
                                                                                                                              
                                                                                                                              	// transaction fields
                                                                                                                              	TransactionHash string `json:"transaction_hash"`
                                                                                                                              	Memo            struct {
                                                                                                                              		Type  string `json:"memo_type"`
                                                                                                                              		Value string `json:"memo"`
                                                                                                                              	}
                                                                                                                              }

                                                                                                                              type PaymentHandler

                                                                                                                              type PaymentHandler func(Payment)

                                                                                                                                PaymentHandler is a function that is called when a new payment is received

                                                                                                                                type Price

                                                                                                                                type Price = hProtocol.Price

                                                                                                                                  Deprecated: use protocols/horizon instead

                                                                                                                                  type PriceLevel

                                                                                                                                  type PriceLevel = hProtocol.PriceLevel

                                                                                                                                    Deprecated: use protocols/horizon instead

                                                                                                                                    type Problem

                                                                                                                                    type Problem struct {
                                                                                                                                    	Type     string                     `json:"type"`
                                                                                                                                    	Title    string                     `json:"title"`
                                                                                                                                    	Status   int                        `json:"status"`
                                                                                                                                    	Detail   string                     `json:"detail,omitempty"`
                                                                                                                                    	Instance string                     `json:"instance,omitempty"`
                                                                                                                                    	Extras   map[string]json.RawMessage `json:"extras,omitempty"`
                                                                                                                                    }

                                                                                                                                      Deprecated: use protocols/horizon instead

                                                                                                                                      func (Problem) ToProblem

                                                                                                                                      func (prob Problem) ToProblem() problem.P

                                                                                                                                        ToProblem converts the Problem to a problem.P

                                                                                                                                        type Root

                                                                                                                                        type Root = hProtocol.Root

                                                                                                                                          Deprecated: use protocols/horizon instead

                                                                                                                                          type Signer

                                                                                                                                          type Signer = hProtocol.Signer

                                                                                                                                            Deprecated: use protocols/horizon instead

                                                                                                                                            type StartTime

                                                                                                                                            type StartTime int64

                                                                                                                                              StartTime is an integer values of timestamp

                                                                                                                                              type Trade

                                                                                                                                              type Trade = hProtocol.Trade

                                                                                                                                                Deprecated: use protocols/horizon instead

                                                                                                                                                type TradeAggregation

                                                                                                                                                type TradeAggregation = hProtocol.TradeAggregation

                                                                                                                                                  Deprecated: use protocols/horizon instead

                                                                                                                                                  type TradeAggregationsPage

                                                                                                                                                  type TradeAggregationsPage struct {
                                                                                                                                                  	Links    hal.Links `json:"_links"`
                                                                                                                                                  	Embedded struct {
                                                                                                                                                  		Records []TradeAggregation `json:"records"`
                                                                                                                                                  	} `json:"_embedded"`
                                                                                                                                                  }

                                                                                                                                                    TradeAggregationsPage returns a list of aggregated trade records, aggregated by resolution

                                                                                                                                                    type TradesPage

                                                                                                                                                    type TradesPage struct {
                                                                                                                                                    	Links    hal.Links `json:"_links"`
                                                                                                                                                    	Embedded struct {
                                                                                                                                                    		Records []Trade `json:"records"`
                                                                                                                                                    	} `json:"_embedded"`
                                                                                                                                                    }

                                                                                                                                                      TradesPage returns a list of trade records

                                                                                                                                                      type Transaction

                                                                                                                                                      type Transaction = hProtocol.Transaction

                                                                                                                                                        Deprecated: use protocols/horizon instead

                                                                                                                                                        type TransactionHandler

                                                                                                                                                        type TransactionHandler func(Transaction)

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

                                                                                                                                                          type TransactionResultCodes

                                                                                                                                                          type TransactionResultCodes = hProtocol.TransactionResultCodes

                                                                                                                                                            Deprecated: use protocols/horizon instead

                                                                                                                                                            type TransactionSuccess

                                                                                                                                                            type TransactionSuccess = hProtocol.TransactionSuccess

                                                                                                                                                              Deprecated: use protocols/horizon instead

                                                                                                                                                              type TransactionsPage

                                                                                                                                                              type TransactionsPage struct {
                                                                                                                                                              	Links    hal.Links `json:"_links"`
                                                                                                                                                              	Embedded struct {
                                                                                                                                                              		Records []hProtocol.Transaction `json:"records"`
                                                                                                                                                              	} `json:"_embedded"`
                                                                                                                                                              }