1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111

use reqwest::IntoUrl;
use shuttle_core::{PublicKey, SignedTransaction};
use client::InnerClient;
use error::{Error, Result};
use accounts::AccountsRequest;
use assets::AssetsRequest;
use effects::EffectsRequest;
use ledgers::LedgersRequest;
use offers::OffersRequest;
use operations::OperationsRequest;
use orderbook::OrderbookRequest;
use paths::PathsRequest;
use payments::PaymentsRequest;
use trade_aggregations::TradeAggregationsRequest;
use trades::TradesRequest;
use transactions::TransactionsRequest;
use submit_transaction::SubmitTransactionRequest;
use friendbot::FriendbotRequest;

/// Handle connection to the Horizon server.
#[derive(Debug, Clone)]
pub struct Server {
    inner: InnerClient,
}

impl Server {
    /// Create a new `Server`. Will return error if the connection is not secure.
    pub fn new<U: IntoUrl>(horizon_url: U) -> Result<Server> {
        let horizon_url = horizon_url.into_url()?;
        if horizon_url.scheme() == "http" {
            return Err(Error::UnsecureConnection);
        }
        Self::new_unsecure(horizon_url)
    }

    /// Create a new `Server`.
    pub fn new_unsecure<U: IntoUrl>(horizon_url: U) -> Result<Server> {
        let inner = InnerClient::new(horizon_url.into_url()?)?;
        Ok(Server { inner })
    }

    /// Create accounts request.
    pub fn accounts(&self) -> AccountsRequest {
        AccountsRequest::new(self.inner.clone())
    }

    /// Create assets request.
    pub fn assets(&self) -> AssetsRequest {
        AssetsRequest::new(self.inner.clone())
    }

    /// Create effects request.
    pub fn effects(&self) -> EffectsRequest {
        EffectsRequest::new(self.inner.clone())
    }

    /// Create ledgers request.
    pub fn ledgers(&self) -> LedgersRequest {
        LedgersRequest::new()
    }

    /// Create offers request.
    pub fn offers(&self) -> OffersRequest {
        unimplemented!()
    }

    /// Create operations request.
    pub fn operations(&self) -> OperationsRequest {
        unimplemented!()
    }

    /// Create orderbook request.
    pub fn orderbook(&self) -> OrderbookRequest {
        unimplemented!()
    }

    /// Create paths request.
    pub fn paths(&self) -> PathsRequest {
        unimplemented!()
    }

    /// Create payments request.
    pub fn payments(&self) -> PaymentsRequest {
        unimplemented!()
    }

    /// Create trade aggregation request.
    pub fn trade_aggregations(&self) -> TradeAggregationsRequest {
        unimplemented!()
    }

    /// Create trades request.
    pub fn trades(&self) -> TradesRequest {
        unimplemented!()
    }

    /// Create transactions request.
    pub fn transactions(&self) -> TransactionsRequest {
        unimplemented!()
    }

    /// Create friendbot request.
    pub fn friendbot(&self, account_id: &PublicKey) -> Result<FriendbotRequest> {
        FriendbotRequest::new(self.inner.clone(), &account_id)
    }

    /// Submit transaction to server.
    pub fn submit_transaction(&self, tx: &SignedTransaction) -> Result<SubmitTransactionRequest> {
        SubmitTransactionRequest::new(self.inner.clone(), &tx)
    }
}