cli: Add upgrade did command to cli (#1075)

* Protos

* Add upgrade did to cli

* Cleanup imports

Author: tmarkovski

cli/src/cli.yaml

@@ -329,6 +329,31 @@ subcommands:
                   required: false
         - invitation_status:
             about: Check invitation status
+        - upgrade-did:
+            about: Upgrade a public DID to a different method
+            args:
+              - email:
+                  long: email
+                  help: Email address of the wallet owner
+                  takes_value: true
+                  required: false
+              - wallet-id:
+                  long: wallet-id
+                  help: Wallet ID of the owner
+                  takes_value: true
+                  required: false
+              - method:
+                  long: method
+                  help: "DID method to upgrade to (ex: 'ion')"
+                  takes_value: true
+                  required: true
+              - method-options:
+                  long: method-options
+                  help: "DID method options (ex: 'mainnet', 'testnet')"
+                  takes_value: true
+                  required: false
+
+
 args:
   - json:
       long: json

cli/src/parser/provider.rs

@@ -4,17 +4,19 @@ use std::fmt::{self, Display, Formatter};
 
 pub(crate) fn parse(args: &ArgMatches) -> Result<Command, Error> {
     if args.subcommand_matches("create-ecosystem").is_some() {
-        create_ecosystem(&args.subcommand_matches("create-ecosystem").expect("Error parsing request"))
+        create_ecosystem(args.subcommand_matches("create-ecosystem").ok_or(Error::MissingArguments)?)
     } else if args.subcommand_matches("update-ecosystem").is_some() {
-        update_ecosystem(&args.subcommand_matches("update-ecosystem").expect("Error parsing request"))
+        update_ecosystem(args.subcommand_matches("update-ecosystem").ok_or(Error::MissingArguments)?)
     } else if args.subcommand_matches("ecosystem-info").is_some() {
         ecosystem_info()
     } else if args.subcommand_matches("invite").is_some() {
-        invite(&args.subcommand_matches("invite").expect("Error parsing request"))
+        invite(args.subcommand_matches("invite").ok_or(Error::MissingArguments)?)
     } else if args.subcommand_matches("add-webhook").is_some() {
-        add_webhook(&args.subcommand_matches("add-webhook").expect("Error parsing request"))
+        add_webhook(args.subcommand_matches("add-webhook").ok_or(Error::MissingArguments)?)
     } else if args.subcommand_matches("delete-webhook").is_some() {
-        delete_webhook(&args.subcommand_matches("delete-webhook").expect("Error parsing request"))
+        delete_webhook(args.subcommand_matches("delete-webhook").ok_or(Error::MissingArguments)?)
+    } else if args.subcommand_matches("upgrade-did").is_some() {
+        upgrade_did(args.subcommand_matches("upgrade-did").ok_or(Error::MissingArguments)?)
     } else {
         Err(Error::MissingArguments)
     }
@@ -89,6 +91,17 @@ fn invite(args: &ArgMatches) -> Result<Command, Error> {
     }))
 }
 
+fn upgrade_did(args: &ArgMatches) -> Result<Command, Error> {
+    let ecosystem = UpgradeDidArgs {
+        method: args.value_of("method").ok_or_else(|| Error::MissingArguments)?.into(),
+        email: args.value_of("email").map(|x| x.into()),
+        wallet_id: args.value_of("wallet-id").map(|x| x.into()),
+        method_options: args.value_of("method-options").map(|x| x.into()),
+    };
+
+    Ok(Command::UpgradeDid(ecosystem))
+}
+
 #[derive(Debug, PartialEq)]
 pub enum Command<'a> {
     CreateEcosystem(CreateEcosystemArgs),
@@ -97,6 +110,7 @@ pub enum Command<'a> {
     AddWebhook(AddWebhookArgs),
     DeleteWebhook(DeleteWebhookArgs),
     Invite(InviteArgs<'a>),
+    UpgradeDid(UpgradeDidArgs),
     InvitationStatus,
 }
 
@@ -107,6 +121,14 @@ pub struct CreateEcosystemArgs {
     pub alias: String,
 }
 
+#[derive(Debug, PartialEq)]
+pub struct UpgradeDidArgs {
+    pub method: String,
+    pub method_options: Option<String>,
+    pub email: Option<String>,
+    pub wallet_id: Option<String>,
+}
+
 #[derive(Debug, PartialEq)]
 pub struct UpdateEcosystemArgs {
     pub description: Option<String>,

cli/src/proto/services/common/v1/mod.rs

@@ -34,3 +34,24 @@ impl ResponseStatus {
         }
     }
 }
+/// Enum of all supported DID Methods
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum SupportedDidMethod {
+    /// The did:key method -- all wallets use this by default
+    Key = 0,
+    /// The did:ion method
+    Ion = 1,
+}
+impl SupportedDidMethod {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            SupportedDidMethod::Key => "KEY",
+            SupportedDidMethod::Ion => "ION",
+        }
+    }
+}

cli/src/proto/services/provider/v1/mod.rs

@@ -248,10 +248,38 @@ pub struct EcosystemInfoRequest {}
 /// Response to `InfoRequest`
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
 pub struct EcosystemInfoResponse {
-    /// Ecosystem corresponding to requested `ecosystem_id`
+    /// Ecosystem corresponding to current ecosystem in the account token
     #[prost(message, optional, tag = "1")]
     pub ecosystem: ::core::option::Option<Ecosystem>,
 }
+/// Request to fetch information about an ecosystem
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct GetPublicEcosystemInfoRequest {
+    #[prost(string, tag = "1")]
+    pub ecosystem_id: ::prost::alloc::string::String,
+}
+/// Response to `InfoRequest`
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct GetPublicEcosystemInfoResponse {
+    /// Ecosystem corresponding to requested `ecosystem_id`
+    #[prost(message, optional, tag = "1")]
+    pub ecosystem: ::core::option::Option<PublicEcosystemInformation>,
+}
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct PublicEcosystemInformation {
+    /// Public name of this ecosystem
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    /// Public domain for the owner of this ecosystem
+    #[prost(string, tag = "2")]
+    pub domain: ::prost::alloc::string::String,
+    /// Trinsic verified the domain is owned by the owner of this ecosystem
+    #[prost(bool, tag = "3")]
+    pub domain_verified: bool,
+    /// Style display information
+    #[prost(message, optional, tag = "4")]
+    pub style_display: ::core::option::Option<EcosystemDisplay>,
+}
 /// Request to generate an authentication token for the current account
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
 pub struct GenerateTokenRequest {
@@ -293,19 +321,18 @@ pub struct GetEventTokenResponse {
     pub token: ::prost::alloc::string::String,
 }
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
-pub struct RetrieveVerificationRecordRequest {}
+pub struct RetrieveDomainVerificationRecordRequest {}
 /// Response message containing a TXT record content for domain url verification
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
-pub struct RetrieveVerificationRecordResponse {
+pub struct RetrieveDomainVerificationRecordResponse {
     /// TXT code to use for domain verification
     #[prost(string, tag = "1")]
     pub verification_txt: ::prost::alloc::string::String,
 }
-/// TODO - Should we allow specifying which ecosystem to use?
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
-pub struct RefreshVerificationStatusRequest {}
+pub struct RefreshDomainVerificationStatusRequest {}
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
-pub struct RefreshVerificationStatusResponse {
+pub struct RefreshDomainVerificationStatusResponse {
     /// Domain URL verified
     #[prost(string, tag = "1")]
     pub domain: ::prost::alloc::string::String,
@@ -384,6 +411,109 @@ pub struct GetAuthorizationsResponse {
     #[prost(message, repeated, tag = "1")]
     pub grants: ::prost::alloc::vec::Vec<Grant>,
 }
+/// Search for issuers/holders/verifiers
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct SearchWalletConfigurationsRequest {
+    /// SQL filter to execute. `SELECT * FROM _ WHERE \[**queryFilter**\]`
+    #[prost(string, tag = "1")]
+    pub query_filter: ::prost::alloc::string::String,
+    /// Token provided by previous `SearchResponse`
+    /// if more data is available for query
+    #[prost(string, tag = "2")]
+    pub continuation_token: ::prost::alloc::string::String,
+}
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct SearchWalletConfigurationResponse {
+    /// Results matching the search query
+    #[prost(message, repeated, tag = "1")]
+    pub results: ::prost::alloc::vec::Vec<WalletConfiguration>,
+    /// Whether more results are available for this query via `continuation_token`
+    #[prost(bool, tag = "2")]
+    pub has_more: bool,
+    /// Token to fetch next set of results via `SearchRequest`
+    #[prost(string, tag = "4")]
+    pub continuation_token: ::prost::alloc::string::String,
+}
+/// Strongly typed information about wallet configurations
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct WalletConfiguration {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub email: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub sms: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub wallet_id: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub public_did: ::prost::alloc::string::String,
+}
+/// Options for creation of DID on the ION network
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct IonOptions {
+    /// ION network on which DID should be published
+    #[prost(enumeration = "ion_options::IonNetwork", tag = "1")]
+    pub network: i32,
+}
+/// Nested message and enum types in `IonOptions`.
+pub mod ion_options {
+    #[derive(::serde::Serialize, ::serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    #[repr(i32)]
+    pub enum IonNetwork {
+        TestNet = 0,
+        MainNet = 1,
+    }
+    impl IonNetwork {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                IonNetwork::TestNet => "TestNet",
+                IonNetwork::MainNet => "MainNet",
+            }
+        }
+    }
+}
+/// Request to upgrade a wallet
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct UpgradeDidRequest {
+    /// DID Method to which wallet should be upgraded
+    #[prost(enumeration = "super::super::common::v1::SupportedDidMethod", tag = "3")]
+    pub method: i32,
+    #[prost(oneof = "upgrade_did_request::Account", tags = "1, 2")]
+    pub account: ::core::option::Option<upgrade_did_request::Account>,
+    #[prost(oneof = "upgrade_did_request::Options", tags = "4")]
+    pub options: ::core::option::Option<upgrade_did_request::Options>,
+}
+/// Nested message and enum types in `UpgradeDidRequest`.
+pub mod upgrade_did_request {
+    #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Oneof)]
+    pub enum Account {
+        /// Email address of account to upgrade.
+        /// Mutually exclusive with `walletId`.
+        #[prost(string, tag = "1")]
+        Email(::prost::alloc::string::String),
+        /// Wallet ID of account to upgrade.
+        /// Mutually exclusive with `email`.
+        #[prost(string, tag = "2")]
+        WalletId(::prost::alloc::string::String),
+    }
+    #[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Oneof)]
+    pub enum Options {
+        /// Configuration for creation of DID on ION network
+        #[prost(message, tag = "4")]
+        IonOptions(super::IonOptions),
+    }
+}
+/// Response to `UpgradeDIDRequest`
+#[derive(::serde::Serialize, ::serde::Deserialize, Clone, PartialEq, ::prost::Message)]
+pub struct UpgradeDidResponse {
+    /// New DID of wallet
+    #[prost(string, tag = "1")]
+    pub did: ::prost::alloc::string::String,
+}
 /// Type of participant being invited to ecosystem
 #[derive(::serde::Serialize, ::serde::Deserialize, Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -519,7 +649,7 @@ pub mod provider_client {
             let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/RevokeAuthorization");
             self.inner.unary(request.into_request(), path, codec).await
         }
-        /// Retreive the list of permissions for this particular account/ecosystem
+        /// Retrieve the list of permissions for this particular account/ecosystem
         pub async fn get_authorizations(
             &mut self,
             request: impl tonic::IntoRequest<super::GetAuthorizationsRequest>,
@@ -571,6 +701,19 @@ pub mod provider_client {
             let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/EcosystemInfo");
             self.inner.unary(request.into_request(), path, codec).await
         }
+        /// Get public ecosystem information about *any* ecosystem
+        pub async fn get_public_ecosystem_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetPublicEcosystemInfoRequest>,
+        ) -> Result<tonic::Response<super::GetPublicEcosystemInfoResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::new(tonic::Code::Unknown, format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/GetPublicEcosystemInfo");
+            self.inner.unary(request.into_request(), path, codec).await
+        }
         /// Generates an unprotected authentication token that can be used to
         /// configure server side applications
         pub async fn generate_token(
@@ -637,30 +780,56 @@ pub mod provider_client {
             let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/GetEventToken");
             self.inner.unary(request.into_request(), path, codec).await
         }
+        /// Upgrade a wallet's DID from `did:key` to another method
+        pub async fn upgrade_did(
+            &mut self,
+            request: impl tonic::IntoRequest<super::UpgradeDidRequest>,
+        ) -> Result<tonic::Response<super::UpgradeDidResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::new(tonic::Code::Unknown, format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/UpgradeDID");
+            self.inner.unary(request.into_request(), path, codec).await
+        }
         /// Retrieve a random hash TXT that can be used to verify domain ownership
-        pub async fn retrieve_verification_record(
+        pub async fn retrieve_domain_verification_record(
+            &mut self,
+            request: impl tonic::IntoRequest<super::RetrieveDomainVerificationRecordRequest>,
+        ) -> Result<tonic::Response<super::RetrieveDomainVerificationRecordResponse>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| tonic::Status::new(tonic::Code::Unknown, format!("Service was not ready: {}", e.into())))?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/RetrieveDomainVerificationRecord");
+            self.inner.unary(request.into_request(), path, codec).await
+        }
+        /// Call to verify domain
+        pub async fn refresh_domain_verification_status(
             &mut self,
-            request: impl tonic::IntoRequest<super::RetrieveVerificationRecordRequest>,
-        ) -> Result<tonic::Response<super::RetrieveVerificationRecordResponse>, tonic::Status> {
+            request: impl tonic::IntoRequest<super::RefreshDomainVerificationStatusRequest>,
+        ) -> Result<tonic::Response<super::RefreshDomainVerificationStatusResponse>, tonic::Status> {
             self.inner
                 .ready()
                 .await
                 .map_err(|e| tonic::Status::new(tonic::Code::Unknown, format!("Service was not ready: {}", e.into())))?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/RetrieveVerificationRecord");
+            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/RefreshDomainVerificationStatus");
             self.inner.unary(request.into_request(), path, codec).await
         }
-        /// Call to verif
-        pub async fn refresh_verification_status(
+        /// Search for issuers/providers/verifiers in the current ecosystem
+        pub async fn search_wallet_configurations(
             &mut self,
-            request: impl tonic::IntoRequest<super::RefreshVerificationStatusRequest>,
-        ) -> Result<tonic::Response<super::RefreshVerificationStatusResponse>, tonic::Status> {
+            request: impl tonic::IntoRequest<super::SearchWalletConfigurationsRequest>,
+        ) -> Result<tonic::Response<super::SearchWalletConfigurationResponse>, tonic::Status> {
             self.inner
                 .ready()
                 .await
                 .map_err(|e| tonic::Status::new(tonic::Code::Unknown, format!("Service was not ready: {}", e.into())))?;
             let codec = tonic::codec::ProstCodec::default();
-            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/RefreshVerificationStatus");
+            let path = http::uri::PathAndQuery::from_static("/services.provider.v1.Provider/SearchWalletConfigurations");
             self.inner.unary(request.into_request(), path, codec).await
         }
     }