Feature/asserter

.gitattributes

@@ -0,0 +1 @@
+* text eol=lf

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+  "cSpell.words": [
+    "SECP"
+  ]
+}

examples/mentat-cli/src/account.rs

@@ -1,5 +1,5 @@
 use clap::Parser;
-use mentat::{identifiers::AccountIdentifier, models::Currency};
+use mentat::types::{AccountIdentifier, NullableCurrency};
 
 #[derive(Parser, Clone)]
 pub(crate) struct AccountOpts {
@@ -19,12 +19,12 @@ impl AccountOpts {
         .into()
     }
 
-    pub(crate) fn get_currencies(&self) -> Option<Vec<Currency>> {
-        if self.currencies.is_empty() {
-            return None;
-        }
-
-        Some(self.currencies.iter().cloned().map(|c| c.into()).collect())
+    pub(crate) fn get_currencies(&self) -> Vec<Option<NullableCurrency>> {
+        self.currencies
+            .iter()
+            .cloned()
+            .map(|c| Some(c.into()))
+            .collect()
     }
 }
 

examples/mentat-cli/src/main.rs

@@ -2,10 +2,16 @@ use clap::Parser;
 use mentat::{
     anyhow,
     client::Client,
-    identifiers::{BlockIdentifier, NetworkIdentifier, PartialBlockIdentifier},
-    requests::{AccountBalanceRequest, AccountCoinsRequest, MetadataRequest},
     serde_json::json,
     tokio,
+    types::{
+        BlockIdentifier,
+        NetworkIdentifier,
+        NullableAccountBalanceRequest,
+        NullableAccountCoinsRequest,
+        NullableMetadataRequest,
+        PartialBlockIdentifier,
+    },
 };
 
 use crate::{account::AccountSubCommand, network::NetworkSubCommand};
@@ -33,7 +39,7 @@ struct Opts {
     pub(crate) subnetwork: String,
 
     #[clap(long)]
-    pub(crate) index: Option<u64>,
+    pub(crate) index: Option<i64>,
     #[clap(long)]
     pub(crate) hash: Option<String>,
 }
@@ -102,32 +108,32 @@ async fn main() -> anyhow::Result<()> {
     match &main_opts.subcmd {
         MainSubCommand::Network(sub_opts) => match &sub_opts.subcmd {
             NetworkSubCommand::List => {
-                display!(client.network_list(&MetadataRequest::default()))
+                display!(client.network_list(NullableMetadataRequest::default()))
             }
             NetworkSubCommand::Options => {
                 let network = get_first_network().await?;
-                display!(client.network_options(&network.into()));
+                display!(client.network_options(network.into()));
             }
             NetworkSubCommand::Status => {
                 let network = get_first_network().await?;
-                display!(client.network_status(&network.into()));
+                display!(client.network_status(network.into()));
             }
         },
         MainSubCommand::Account(sub_opts) => match &sub_opts.subcmd {
             AccountSubCommand::Balance(_opts) => {
                 let network = get_first_network().await?;
-                display!(client.account_balance(&AccountBalanceRequest {
-                    network_identifier: network,
-                    account_identifier: sub_opts.account_id(),
+                display!(client.account_balance(NullableAccountBalanceRequest {
+                    network_identifier: Some(network),
+                    account_identifier: Some(sub_opts.account_id()),
                     currencies: sub_opts.get_currencies(),
                     block_identifier: main_opts.partial_block_id(),
                 }));
             }
             AccountSubCommand::Coins(_opts) => {
                 let network = get_first_network().await?;
-                display!(client.account_coins(&AccountCoinsRequest {
-                    network_identifier: network,
-                    account_identifier: sub_opts.account_id(),
+                display!(client.account_coins(NullableAccountCoinsRequest {
+                    network_identifier: Some(network),
+                    account_identifier: Some(sub_opts.account_id()),
                     currencies: sub_opts.get_currencies(),
                     ..Default::default()
                 }));
@@ -141,23 +147,23 @@ async fn main() -> anyhow::Result<()> {
                     .block_id()
                     .expect("Expected a block identifier (--hash, --index)");
                 display!(
-                    client.block_transaction(&(network, block, transaction.clone().into()).into())
+                    client.block_transaction((network, block, transaction.clone().into()).into())
                 );
             } else {
                 // find a specific block
                 let block = main_opts
                     .partial_block_id()
                     .expect("Expected a partial block identifier (--hash, --index)");
-                display!(client.block(&(network, block).into()));
+                display!(client.block((network, block).into()));
             }
         }
         MainSubCommand::Mempool(opts) => {
             let network = get_first_network().await?;
             // handle --transaction flag
             if let Some(transaction) = &opts.transaction {
-                display!(client.mempool_transaction(&(network, transaction.clone().into()).into()));
+                display!(client.mempool_transaction((network, transaction.clone().into()).into()));
             } else {
-                display!(client.mempool(&network.into()));
+                display!(client.mempool(network.into()));
             }
         }
     }

examples/mentat-cli/src/network.rs

@@ -2,8 +2,7 @@ use clap::Parser;
 use mentat::{
     anyhow::Result,
     client::Client,
-    identifiers::NetworkIdentifier,
-    requests::MetadataRequest,
+    types::{NetworkIdentifier, NullableMetadataRequest},
 };
 
 #[derive(Parser)]
@@ -25,11 +24,11 @@ pub(crate) async fn get_network(
     client: &Client,
     net_ident: NetworkIdentifier,
 ) -> Result<Option<NetworkIdentifier>> {
-    Ok(Some(
+    Ok(
         if net_ident.blockchain.is_empty() && net_ident.network.is_empty() {
             // get the first network
             if let Some(net) = client
-                .network_list(&MetadataRequest::default())
+                .network_list(NullableMetadataRequest::default())
                 .await?
                 .network_identifiers
                 .first()
@@ -39,9 +38,9 @@ pub(crate) async fn get_network(
                 return Ok(None);
             }
         } else {
-            net_ident
+            Some(net_ident)
         },
-    ))
+    )
 }
 
 /// Gets the first network in the networks list, prints "null" or "network not

mentat-macros/src/lib.rs

@@ -5,8 +5,10 @@
 
 extern crate proc_macro;
 
+mod nullable;
 mod route_builder;
 
+use nullable::create_nullable_counterpart;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::quote;
@@ -159,3 +161,10 @@ pub fn main(attr: TokenStream, item: TokenStream) -> TokenStream {
     out.extend(gen_main(&server_call, server_type, cache_type));
     out.into()
 }
+
+/// TODO doc
+#[proc_macro_derive(Nullable, attributes(retain))]
+pub fn nullable(item: TokenStream) -> TokenStream {
+    let item = parse_macro_input!(item as ItemStruct);
+    create_nullable_counterpart(item)
+}