Sdk 750 loginanonymous dart ruby typescript

dart/lib/src/account_service.dart

@@ -2,6 +2,7 @@ import 'dart:convert';
 import 'dart:typed_data';
 
 import 'package:okapi_dart/okapi.dart';
+import 'package:okapi_dart/proto/okapi/hashing/v1/hashing.pb.dart';
 import 'package:okapi_dart/proto/okapi/security/v1/security.pb.dart';
 import 'package:trinsic_dart/src/proto/sdk/options/v1/options.pb.dart';
 import 'package:trinsic_dart/src/proto/services/account/v1/account.pbgrpc.dart';
@@ -16,7 +17,7 @@ class AccountService extends ServiceBase {
   }
 
   Future<String> signIn({SignInRequest? request}) async {
-    request = request ?? SignInRequest();
+    request ??= SignInRequest();
     request.ecosystemId = request.ecosystemId != ""
         ? request.ecosystemId
         : serviceOptions.defaultEcosystem;
@@ -67,12 +68,36 @@ class AccountService extends ServiceBase {
     return Base64Encoder.urlSafe().convert(protectedProfile.writeToBuffer());
   }
 
-  Future<LoginResponse> login(LoginRequest request) async {
+  Future<LoginResponse> login({LoginRequest? request}) async {
+    request ??= LoginRequest();
+    request.ecosystemId = request.ecosystemId != ""
+        ? request.ecosystemId
+        : serviceOptions.defaultEcosystem;
     return await client.login(request);
   }
 
-  Future<LoginConfirmResponse> loginConfirm(LoginConfirmRequest request) async {
-    return await client.loginConfirm(request);
+  Future<String> loginConfirm(String challenge, String authCode) async {
+    var hashed = Hashing.blake3Hash(Blake3HashRequest(data: Uint8List.fromList(utf8.encode(authCode))));
+    var request = LoginConfirmRequest(challenge: Uint8List.fromList(utf8.encode(challenge)), confirmationCodeHashed: hashed.digest);
+    var response = await client.loginConfirm(request);
+
+    var token = Base64Encoder.urlSafe().convert(response.profile.writeToBuffer());
+    if (response.profile.protection.enabled) {
+      token = unprotect(token, authCode);
+    }
+    return token;
+  }
+
+  Future<String> loginAnonymous() async {
+    var response = await login();
+
+    if (response.profile.protection.enabled) {
+      throw Exception("protected profile returned from login()");
+    }
+    // Tokenize and return
+    var authToken =
+        Base64Encoder.urlSafe().convert(response.profile.writeToBuffer());
+    return authToken;
   }
 
   Future<AccountInfoResponse> getInfo() async {
@@ -87,7 +112,8 @@ class AccountService extends ServiceBase {
     return await client.revokeDevice(request);
   }
 
-  Future<AuthorizeWebhookResponse> authorizeWebhook(AuthorizeWebhookRequest request) async {
+  Future<AuthorizeWebhookResponse> authorizeWebhook(
+      AuthorizeWebhookRequest request) async {
     return await client.authorizeWebhook(request);
   }
 }

ruby/lib/security.rb

@@ -32,7 +32,7 @@ def get_auth_header(account_profile, message)
       unless request_hash.length.zero?
         request_hash = Okapi::Hashing.blake3_hash(Okapi::Hashing::V1::Blake3HashRequest.new(data: request_hash)).digest
       end
-      nonce = Trinsic::Common_V1::Nonce.new(timestamp: (Time.now.to_f * 1000).to_int, request_hash: request_hash)
+      nonce = Trinsic::Common::Nonce.new(timestamp: (Time.now.to_f * 1000).to_int, request_hash: request_hash)
       request = Okapi::Security::V1::CreateOberonProofRequest.new(token: account_profile.auth_token,
                                                                   data: account_profile.auth_data,
                                                                   nonce: Google::Protobuf.encode(nonce))

ruby/lib/services/account_service.rb

@@ -9,18 +9,18 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = Account_V1::Account::Stub.new(url_string, channel_creds)
+        @client = Account::Account::Stub.new(url_string, channel_creds)
       else
-        @client = Account_V1::Account::Stub.new(url_string, :this_channel_is_insecure)
+        @client = Account::Account::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 
     def sign_in(request = nil)
-      request ||= Account_V1::SignInRequest.new
-      request.details = request.details || Account_V1::AccountDetails.new
+      request ||= Account::SignInRequest.new
+      request.details = request.details || Account::AccountDetails.new
       request.ecosystem_id = request.ecosystem_id.empty? ? @service_options.default_ecosystem : request.ecosystem_id
       auth_token = @client.sign_in(request).profile
-      encoded_profile = Base64.urlsafe_encode64(Account_V1::AccountProfile.encode(auth_token))
+      encoded_profile = Base64.urlsafe_encode64(Account::AccountProfile.encode(auth_token))
       self.auth_token = encoded_profile
       encoded_profile
     end
@@ -31,7 +31,7 @@ def unprotect(profile, security_code)
       request.blinding += [security_code]
       result = Okapi::Oberon.unblind_token request
       cloned.auth_token = result.token
-      cloned.protection = Account_V1::TokenProtection.new(enabled: false, method: Account_V1::ConfirmationMethod.None)
+      cloned.protection = Account::TokenProtection.new(enabled: false, method: Account::ConfirmationMethod.None)
       cloned
     end
 
@@ -41,20 +41,39 @@ def protect(profile, security_code)
       request.blinding += [security_code]
       result = Okapi::Oberon.blind_token request
       cloned.auth_token = result.token
-      cloned.protection = Account_V1::TokenProtection.new(enabled: true, method: Account_V1::ConfirmationMethod.Other)
+      cloned.protection = Account::TokenProtection.new(enabled: true, method: Account::ConfirmationMethod.Other)
       cloned
     end
 
-    def login(request)
-      @client.login(request, metadata: metadata(request))
+    def login(request = nil)
+      request ||= Account::LoginRequest.new
+      request.ecosystem_id = request.ecosystem_id.empty? ? @service_options.default_ecosystem : request.ecosystem_id
+      @client.login(request)
+    end
+
+    def login_confirm(challenge, auth_code)
+      hashed = Okapi::Hashing::blake3_hash(Okapi::Hashing::V1::Blake3HashRequest.new(data: auth_code))
+      request = Account::LoginConfirmRequest.new(challenge: challenge, confirmation_code_hashed: hashed.digest)
+      response = @client.login_confirm(request, metadata: metadata(request))
+      return nil if response.profile.nil?
+
+      profile = response.profile
+      if response.profile.protection.enabled
+        profile = unprotect(profile, auth_code)
+      end
+      Base64.urlsafe_encode64(Account::AccountProfile.encode(profile))
     end
 
-    def login_confirm(request)
-      @client.login_confirm(request, metadata: metadata(request))
+    def login_anonymous
+      response = login
+      raise Error('nil profile returned') if response.profile.nil?
+      raise Error('protected profile returned') if response.profile.protection.enabled
+
+      Base64.urlsafe_encode64(Account::AccountProfile.encode(response.profile))
     end
 
     def info
-      request = Account_V1::AccountInfoRequest.new
+      request = Account::AccountInfoRequest.new
       @client.info(request, metadata: metadata(request))
     end
 

ruby/lib/services/credential_service.rb

@@ -9,14 +9,14 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = Credentials_V1::VerifiableCredential::Stub.new(url_string, channel_creds)
+        @client = Credentials::VerifiableCredential::Stub.new(url_string, channel_creds)
       else
-        @client = Credentials_V1::VerifiableCredential::Stub.new(url_string, :this_channel_is_insecure)
+        @client = Credentials::VerifiableCredential::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 
     def issue_credential(request)
-      # Credentials_V1::IssueRequest.new(document_json: JSON.generate(document))
+      # Credentials::IssueRequest.new(document_json: JSON.generate(document))
       @client.issue(request, metadata: metadata(request))
     end
 
@@ -31,25 +31,25 @@ def send(request)
     def create_proof(request)
       # doc_json = nil
       # doc_json = JSON.generate(document) unless document.nil?
-      # request = Credentials_V1::CreateProofRequest.new(item_id: item_id,
+      # request = Credentials::CreateProofRequest.new(item_id: item_id,
       #                                                  reveal_document_json: JSON.generate(reveal_document),
       #                                                  document_json: doc_json)
       @client.create_proof(request, metadata: metadata(request))
       # JSON.parse(response.proof_document_json)
     end
 
     def verify_proof(request)
-      # request = Credentials_V1::VerifyProofRequest.new(proof_document_json: JSON.generate(proof_document))
+      # request = Credentials::VerifyProofRequest.new(proof_document_json: JSON.generate(proof_document))
       @client.verify_proof(request, metadata: metadata(request))
     end
 
     def check_status(request)
-      # request = Credentials_V1::CheckStatusRequest.new(credential_status_id: credential_status_id)
+      # request = Credentials::CheckStatusRequest.new(credential_status_id: credential_status_id)
       @client.check_status(request, metadata: metadata(request))
     end
 
     def update_status(request)
-      # request = Credentials_V1::UpdateStatusRequest.new(credential_status_id: credential_status_id, revoked: revoked)
+      # request = Credentials::UpdateStatusRequest.new(credential_status_id: credential_status_id, revoked: revoked)
       @client.update_status(request, metadata: metadata(request))
     end
   end

ruby/lib/services/provider_service.rb

@@ -9,14 +9,14 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = Provider_V1::Provider::Stub.new(url_string, channel_creds)
+        @client = Provider::Provider::Stub.new(url_string, channel_creds)
       else
-        @client = Provider_V1::Provider::Stub.new(url_string, :this_channel_is_insecure)
+        @client = Provider::Provider::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 
     def create_ecosystem(request = nil)
-      request ||= Provider_V1::CreateEcosystemRequest.new
+      request ||= Provider::CreateEcosystemRequest.new
       @client.create_ecosystem(request)
     end
 

ruby/lib/services/service_base.rb

@@ -14,7 +14,7 @@ def metadata(message)
       end
 
       { 'authorization' => @security_provider.get_auth_header(
-        Account_V1::AccountProfile.decode(Base64.urlsafe_decode64(@service_options.auth_token)), message
+        Account::AccountProfile.decode(Base64.urlsafe_decode64(@service_options.auth_token)), message
       ) }
     end
 

ruby/lib/services/template_service.rb

@@ -9,9 +9,9 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = Template_V1::CredentialTemplates::Stub.new(url_string, channel_creds)
+        @client = Template::CredentialTemplates::Stub.new(url_string, channel_creds)
       else
-        @client = Template_V1::CredentialTemplates::Stub.new(url_string, :this_channel_is_insecure)
+        @client = Template::CredentialTemplates::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 

ruby/lib/services/trust_registry_service.rb

@@ -11,9 +11,9 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = TrustRegistry_V1::TrustRegistry::Stub.new(url_string, channel_creds)
+        @client = TrustRegistry::TrustRegistry::Stub.new(url_string, channel_creds)
       else
-        @client = TrustRegistry_V1::TrustRegistry::Stub.new(url_string, :this_channel_is_insecure)
+        @client = TrustRegistry::TrustRegistry::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 
@@ -42,7 +42,7 @@ def get_membership_status(request)
     end
 
     def search_registry(request = nil)
-      request ||= TrustRegistry_V1::SearchRegistryRequest.new
+      request ||= TrustRegistry::SearchRegistryRequest.new
       request.query = request.query.empty? ? 'SELECT * FROM c OFFSET 0 LIMIT 100' : request.query
       @client.search_registry(request, metadata: metadata(request))
     end

ruby/lib/services/wallet_service.rb

@@ -9,21 +9,21 @@ def initialize(service_options = nil)
       super(service_options)
       if @service_options.server_use_tls
         channel_creds = GRPC::Core::ChannelCredentials.new
-        @client = Wallet_V1::UniversalWallet::Stub.new(url_string, channel_creds)
+        @client = Wallet::UniversalWallet::Stub.new(url_string, channel_creds)
       else
-        @client = Wallet_V1::UniversalWallet::Stub.new(url_string, :this_channel_is_insecure)
+        @client = Wallet::UniversalWallet::Stub.new(url_string, :this_channel_is_insecure)
       end
     end
 
     def search(request = nil)
-      # request = Wallet_V1::SearchRequest.new(query: query)
-      request ||= Wallet_V1::SearchRequest.new
+      # request = Wallet::SearchRequest.new(query: query)
+      request ||= Wallet::SearchRequest.new
       request.query = request.query.empty? ? 'SELECT c.id, c.type, c.data FROM c OFFSET 0 LIMIT 100' : request.query
       @client.search(request, metadata: metadata(request))
     end
 
     def insert_item(request)
-      # request = Wallet_V1::InsertItemRequest.new(item_json: JSON.generate(item))
+      # request = Wallet::InsertItemRequest.new(item_json: JSON.generate(item))
       @client.insert_item(request, metadata: metadata(request))
     end
 

ruby/lib/trinsic_services.rb

@@ -21,24 +21,24 @@
 
 # Module for all Trinsic servers
 module Trinsic
-  Common_V1 = Services::Common::V1
-  Account_V1 = Services::Account::V1
-  Credentials_V1 = Services::Verifiablecredentials::V1
-  Options_V1 = Sdk::Options::V1
-  Provider_V1 = Services::Provider::V1
-  Template_V1 = Services::Verifiablecredentials::Templates::V1
-  TrustRegistry_V1 = Services::Trustregistry::V1
-  Wallet_V1 = Services::Universalwallet::V1
+  Common = Services::Common::V1
+  Account = Services::Account::V1
+  Credentials = Services::Verifiablecredentials::V1
+  Options = Sdk::Options::V1
+  Provider = Services::Provider::V1
+  Template = Services::Verifiablecredentials::Templates::V1
+  TrustRegistry = Services::Trustregistry::V1
+  Wallet = Services::Universalwallet::V1
 
   def self.trinsic_server(auth_token = nil, ecosystem_id = nil)
     server_endpoint = ENV.fetch('TEST_SERVER_ENDPOINT', 'prod.trinsic.cloud')
     server_port = ENV.fetch('TEST_SERVER_PORT', '443')
     server_use_tls = ENV.fetch('TEST_SERVER_USE_TLS', 'true')
     server_authtoken = auth_token || ''
     server_default_ecosystem = ecosystem_id || ENV.fetch('TEST_SERVER_ECOSYSTEM', 'default')
-    Options_V1::ServiceOptions.new(server_endpoint: server_endpoint, server_port: server_port.to_i,
-                                   server_use_tls: server_use_tls.downcase != 'false', auth_token: server_authtoken,
-                                   default_ecosystem: server_default_ecosystem)
+    Options::ServiceOptions.new(server_endpoint: server_endpoint, server_port: server_port.to_i,
+                                server_use_tls: server_use_tls.downcase != 'false', auth_token: server_authtoken,
+                                default_ecosystem: server_default_ecosystem)
   end
 
   class Error < StandardError; end

ruby/test/credential_template_demo.rb

@@ -15,13 +15,13 @@ def credential_template_demo_run
   template_service = Trinsic::TemplateService.new(Trinsic.trinsic_server(account))
 
   # create example template
-  template_request = Trinsic::Template_V1::CreateCredentialTemplateRequest.new(
+  template_request = Trinsic::Template::CreateCredentialTemplateRequest.new(
     name: "My Example Credential: #{SecureRandom.uuid}", allow_additional_fields: false
   )
-  template_request.fields['firstName'] = Trinsic::Template_V1::TemplateField.new(description: 'Given name')
-  template_request.fields['lastName'] = Trinsic::Template_V1::TemplateField.new
+  template_request.fields['firstName'] = Trinsic::Template::TemplateField.new(description: 'Given name')
+  template_request.fields['lastName'] = Trinsic::Template::TemplateField.new
   template_request.fields['age'] =
-    Trinsic::Template_V1::TemplateField.new(type: Trinsic::Template_V1::FieldType::NUMBER, optional: true)
+    Trinsic::Template::TemplateField.new(type: Trinsic::Template::FieldType::NUMBER, optional: true)
   template = template_service.create(template_request)
 
   raise 'template should not be nil' if template.nil?
@@ -31,7 +31,7 @@ def credential_template_demo_run
 
   # issue credential from this template
   values = JSON.generate({ firstName: 'Jane', lastName: 'Doe', age: 42 })
-  credential_json = credential_service.issue_from_template(Trinsic::Credentials_V1::IssueFromTemplateRequest.new(
+  credential_json = credential_service.issue_from_template(Trinsic::Credentials::IssueFromTemplateRequest.new(
                                                              template_id: template.data.id, values_json: values
                                                            ))
   raise 'credential json document should not be nil' if credential_json.document_json.nil?

ruby/test/ecosystem_demo.rb

@@ -10,7 +10,7 @@ def ecosystem_demo_run
   service = Trinsic::ProviderService.new(Trinsic.trinsic_server(account))
 
   # test create ecosystem
-  actual_create = service.create_ecosystem(Trinsic::Provider_V1::CreateEcosystemRequest.new(
+  actual_create = service.create_ecosystem(Trinsic::Provider::CreateEcosystemRequest.new(
                                              description: 'My ecosystem', uri: 'https://example.com'
                                            ))
   raise 'ecosystem should be created' if actual_create.ecosystem.nil?

ruby/test/trust_registry_demo.rb

@@ -13,18 +13,18 @@ def trust_registry_demo_run
 
   # New governance framework
   framework_uri = "urn:egf:#{SecureRandom.uuid}"
-  governance_framework_response = service.add_framework(Trinsic::TrustRegistry_V1::AddFrameworkRequest.new(
+  governance_framework_response = service.add_framework(Trinsic::TrustRegistry::AddFrameworkRequest.new(
                                                           governance_framework_uri: framework_uri, name: "Test Governance Framework - #{SecureRandom.uuid}"
                                                         ))
 
   # register issuer
   did_uri = 'did:example:test'
   type_uri = 'https://schema.org/Card'
-  service.register_member(Trinsic::TrustRegistry_V1::RegisterMemberRequest.new(did_uri: did_uri,
+  service.register_member(Trinsic::TrustRegistry::RegisterMemberRequest.new(did_uri: did_uri,
                                                                                framework_id: governance_framework_response.id, schema_uri: type_uri))
 
   # check issuer status
-  issuer_status = service.get_membership_status(Trinsic::TrustRegistry_V1::GetMembershipStatusRequest.new(
+  issuer_status = service.get_membership_status(Trinsic::TrustRegistry::GetMembershipStatusRequest.new(
                                                   did_uri: did_uri, governance_framework_uri: framework_uri, schema_uri: type_uri
                                                 ))
   raise "Issuer status #{issuer_status.status} should be current" unless issuer_status.status == :CURRENT