metaclips / rustdcr

Decred in Rust

Contains Decred infrastructures in Rust

rustdcr's Issues

Track RPC methods

This issues tracks RPC method that are to be integrated in RustDCR. It is fairly easy to implement RPC methods by fulfilling some rust macros rules.
To create a RPC command, there are chain command macro generators and chain notification macro generators that can be called upon to easily generate RPC client commands and notification.

Client Commands

To create client commands, we

• Generate a future/async type of the RPC command using the build future macros the macros should entail the name of the RPC command with an appended tag Future (example, GetBlock command should be named GetBlockFuture in the build_future macros). build_future macros should also include a Result return type of whatever type the command is to receive from the RPC server (example, GetBlock is to receive a Result<i64, Error>) as its second parameter.
  An on_message function MUST also be created for the the specific future type which handles decoding the data returned by the server to a a required type. GetBlockCount on_message function example
• Generate a command using the command generator macros which
  • Takes the documentation of the chain command as it's first parameter
  • Function name of the RPC command
  • Future type of the RPC command which was generated in step 1
  • RPC command to be sent to the server as a string
  • Array of pointer &[] of JSON value to be sent to the RPC server, example provided. NOTE we should take note of the order of value parameters while sending.
  • The macros last parameter is the input parameter(s) that MUST be passed by the specific command and is to be marshalled and sent to the server. get_block_verbose contains two input parameter block_hash and verbose_tx which must be passed by the client. to generate the get_block_verbose we pass

     command_generator!(
        "get_block_verbose returns a data structure from the server with information
        about a block given its hash.",
        get_block_verbose,
        future_type::GetBlockVerboseFuture,
        commands::METHOD_GET_BLOCK,
        &[
            serde_json::json!(block_hash),
            serde_json::json!(true),
            serde_json::json!(verbose_tx)
        ],
        block_hash: String,
        verbose_tx: bool
    );

where the 5th parameter is the array containing, block_hash, true (as boolean), verbose_tx and the 6th and 7th parameter, block_hash verbose_tx is the function input parameter of get_block_verbose with stated types. The generated function becomes

pub async fn get_block_verbose(&mut self, block_hash: String, verbose_tx: bool) -> Result<future_type::GetBlockVerboseFuture, RpcClientError>

Client Notification

• We generate a future type
• We use a notification_generator macros which entails
  • Documentation as a string
  • Notification function name
  • Future type
  • RPC Command as a string
  • Array of pointer &[] of JSON value to be sent to the RPC server
  • The next input parameter should entail NotificationHandlers that must either be defined using the either_defined() (ensures at least one of the notification handler specified is defined) or all notification handler are defined using all_defined()
  • Last input should consist all function parameters
    Some notification macros are defined here

More here #10

Add continuous integration

Add continuous integration to perform cargo clippy, cargo check, cargo build and code coverage in our codebase

Write wire protocol