Struct snarkos_rpc::RpcImpl

pub struct RpcImpl<S: Storage>(_);

Implements JSON-RPC HTTP endpoint functions for a node. The constructor is given Arc::clone() copies of all needed node components.

Implementations

impl<S: Storage + Send + Sync + 'static> RpcImpl<S>

pub fn new(
    storage: Arc<MerkleTreeLedger<S>>,
    credentials: Option<RpcCredentials>,
    node: Node<S>
) -> Self

Creates a new struct for calling public and private RPC endpoints.

pub fn consensus_layer(&self) -> Result<&Arc<Consensus<S>>, RpcError>

pub fn consensus_parameters(&self) -> Result<&ConsensusParameters, RpcError>

pub fn parameters(&self) -> Result<&PublicParameters<Components>, RpcError>

pub fn memory_pool(&self) -> Result<&Mutex<MemoryPool<Tx>>, RpcError>

impl<S: Storage + Send + Sync + 'static> RpcImpl<S>

The following *_protected functions wrap an authentication check around sensitive functions before being exposed as an RPC endpoint

pub fn validate_auth(&self, meta: Meta) -> Result<(), Error>

Validate the authentication header in the request metadata

pub async fn create_raw_transaction_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around create_raw_transaction

pub async fn create_transaction_kernel_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around create_transaction_kernel

pub async fn create_transaction_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around create_transaction

pub async fn get_record_commitment_count_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around get_record_commitment_count

pub async fn get_record_commitments_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around get_record_commitments

pub async fn get_raw_record_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around get_raw_record

pub async fn decode_record_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around decode_record

pub async fn decrypt_record_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around decrypt_record

pub async fn create_account_protected(
    self,
    params: Params,
    meta: Meta
) -> Result<Value, Error>

Wrap authentication around create_account

pub fn add_protected(&self, io: &mut MetaIoHandler<Meta>)

Expose the protected functions as RPC enpoints

Trait Implementations

impl<S: Storage> Clone for RpcImpl<S>

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: Storage> Deref for RpcImpl<S>

type Target = RpcInner<S>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S: Storage + Send + Sync + 'static> ProtectedRpcFunctions for RpcImpl<S>

Functions that are sensitive and need to be protected with authentication. The authentication logic is defined in validate_auth

fn create_account(&self) -> Result<RpcAccount, RpcError>

Generate a new account private key, account view key, and account address.

fn create_raw_transaction(
    &self,
    transaction_input: TransactionInputs
) -> Result<CreateRawTransactionOuput, RpcError>

Create a new transaction, returning the encoded transaction and the new records.

fn create_transaction_kernel(
    &self,
    transaction_input: TransactionInputs
) -> Result<String, RpcError>

Generates and returns a new transaction kernel.

fn create_transaction(
    &self,
    transaction_kernel: String
) -> Result<CreateRawTransactionOuput, RpcError>

Create a new transaction for a given transaction kernel.

fn get_record_commitment_count(&self) -> Result<usize, RpcError>

Returns the number of record commitments that are stored on the full node.

fn get_record_commitments(&self) -> Result<Vec<String>, RpcError>

Returns a list of record commitments that are stored on the full node.

fn get_raw_record(&self, record_commitment: String) -> Result<String, RpcError>

Returns the hex encoded bytes of a record from its record commitment

fn decrypt_record(
    &self,
    decryption_input: DecryptRecordInput
) -> Result<String, RpcError>

Decrypts the record ciphertext and returns the hex encoded bytes of the record.

fn decode_record(&self, record_bytes: String) -> Result<RecordInfo, RpcError>

Returns information about a record from serialized record bytes.

impl<S: Storage + Send + Sync + 'static> RpcFunctions for RpcImpl<S>

fn get_block(&self, block_hash_string: String) -> Result<BlockInfo, RpcError>

Returns information about a block from a block hash.

fn get_block_count(&self) -> Result<u32, RpcError>

Returns the number of blocks in the canonical chain.

fn get_best_block_hash(&self) -> Result<String, RpcError>

Returns the block hash of the head of the canonical chain.

fn get_block_hash(&self, block_height: u32) -> Result<String, RpcError>

Returns the block hash of the index specified if it exists in the canonical chain.

fn get_raw_transaction(
    &self,
    transaction_id: String
) -> Result<String, RpcError>

Returns the hex encoded bytes of a transaction from its transaction id.

fn get_transaction_info(
    &self,
    transaction_id: String
) -> Result<TransactionInfo, RpcError>

Returns information about a transaction from a transaction id.

fn decode_raw_transaction(
    &self,
    transaction_bytes: String
) -> Result<TransactionInfo, RpcError>

Returns information about a transaction from serialized transaction bytes.

fn send_raw_transaction(
    &self,
    transaction_bytes: String
) -> Result<String, RpcError>

Send raw transaction bytes to this node to be added into the mempool. If valid, the transaction will be stored and propagated to all peers. Returns the transaction id if valid.

fn validate_raw_transaction(
    &self,
    transaction_bytes: String
) -> Result<bool, RpcError>

Validate and return if the transaction is valid.

fn get_connection_count(&self) -> Result<usize, RpcError>

Fetch the number of connected peers this node has.

fn get_peer_info(&self) -> Result<PeerInfo, RpcError>

Returns this nodes connected peers.

fn get_node_info(&self) -> Result<NodeInfo, RpcError>

Returns data about the node.

fn get_block_template(&self) -> Result<BlockTemplate, RpcError>

Returns the current mempool and consensus information known by this node.

fn to_delegate<M: Metadata>(self) -> IoDelegate<Self, M>

Create an IoDelegate, wiring rpc calls to the trait methods.