11056380298

Committed 26 Sep 2024 04:28PM UTC coverage: 48.66% (+0.05%) from 48.609%

Build Type

Committed by

Commit Message

fix: migration to a new eudi.openid4vci library

Signed-off-by: Yurii Shynbuiev <yurii.shynbuiev@iohk.io>

Pull Request Pull Request #1375: fix: OAS and http clients for Kotliln and TypeScript

Run Details

34 of 81 new or added lines in 25 files covered. (41.98%)

182 existing lines in 53 files now uncovered.

7860 of 16153 relevant lines covered (48.66%)

0.49 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

33.9

/cloud-agent/service/server/src/main/scala/org/hyperledger/identus/agent/server/CloudAgentApp.scala

package org.hyperledger.identus.agent.server

import org.hyperledger.identus.agent.notification.WebhookPublisher
import org.hyperledger.identus.agent.server.config.AppConfig
import org.hyperledger.identus.agent.server.http.{ZHttp4sBlazeServer, ZHttpEndpoints}
import org.hyperledger.identus.agent.server.jobs.*
import org.hyperledger.identus.agent.walletapi.model.{Entity, Wallet, WalletSeed}
import org.hyperledger.identus.agent.walletapi.service.{EntityService, ManagedDIDService, WalletManagementService}
import org.hyperledger.identus.agent.walletapi.storage.DIDNonSecretStorage
import org.hyperledger.identus.castor.controller.{DIDRegistrarServerEndpoints, DIDServerEndpoints}
import org.hyperledger.identus.castor.core.service.DIDService
import org.hyperledger.identus.connect.controller.ConnectionServerEndpoints
import org.hyperledger.identus.connect.core.service.ConnectionService
import org.hyperledger.identus.credentialstatus.controller.CredentialStatusServiceEndpoints
import org.hyperledger.identus.event.controller.EventServerEndpoints
import org.hyperledger.identus.event.notification.EventNotificationConfig
import org.hyperledger.identus.iam.authentication.apikey.ApiKeyAuthenticator
import org.hyperledger.identus.iam.entity.http.EntityServerEndpoints
import org.hyperledger.identus.iam.wallet.http.WalletManagementServerEndpoints
import org.hyperledger.identus.issue.controller.IssueServerEndpoints
import org.hyperledger.identus.mercury.{DidOps, HttpClient}
import org.hyperledger.identus.oid4vci.CredentialIssuerServerEndpoints
import org.hyperledger.identus.pollux.core.service.{CredentialService, PresentationService}
import org.hyperledger.identus.pollux.credentialdefinition.CredentialDefinitionRegistryServerEndpoints
import org.hyperledger.identus.pollux.credentialschema.{
  SchemaRegistryServerEndpoints,
  VerificationPolicyServerEndpoints
}
import org.hyperledger.identus.pollux.prex.PresentationExchangeServerEndpoints
import org.hyperledger.identus.pollux.vc.jwt.DidResolver as JwtDidResolver
import org.hyperledger.identus.presentproof.controller.PresentProofServerEndpoints
import org.hyperledger.identus.resolvers.DIDResolver
import org.hyperledger.identus.shared.http.UriResolver
import org.hyperledger.identus.shared.models.{HexString, WalletAccessContext, WalletAdministrationContext, WalletId}
import org.hyperledger.identus.shared.utils.DurationOps.toMetricsSeconds
import org.hyperledger.identus.system.controller.SystemServerEndpoints
import org.hyperledger.identus.verification.controller.VcVerificationServerEndpoints
import zio.*
import zio.metrics.*

object CloudAgentApp {

  def run = for {
    _ <- AgentInitialization.run
    _ <- issueCredentialDidCommExchangesJob.debug.fork
    _ <- presentProofExchangeJob.debug.fork
    _ <- connectDidCommExchangesJob.debug.fork
    _ <- syncDIDPublicationStateFromDltJob.debug.fork
    _ <- syncRevocationStatusListsJob.debug.fork
    _ <- AgentHttpServer.run.tapDefect(e => ZIO.logErrorCause("Agent HTTP Server failure", e)).fork
    fiber <- DidCommHttpServer.run.tapDefect(e => ZIO.logErrorCause("DIDComm HTTP Server failure", e)).fork
    _ <- WebhookPublisher.layer.build.map(_.get[WebhookPublisher]).flatMap(_.run.fork)
    _ <- fiber.join *> ZIO.log(s"Server End")
    _ <- ZIO.never
  } yield ()

  private val issueCredentialDidCommExchangesJob: RIO[
    AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & CredentialService & DIDNonSecretStorage &
      DIDService & ManagedDIDService & PresentationService & WalletManagementService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (IssueBackgroundJobs.issueCredentialDidCommExchanges @@ Metric
        .gauge("issuance_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.issueBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val presentProofExchangeJob: RIO[
    AppConfig & DidOps & UriResolver & DIDResolver & JwtDidResolver & HttpClient & PresentationService &
      CredentialService & DIDNonSecretStorage & DIDService & ManagedDIDService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (PresentBackgroundJobs.presentProofExchanges @@ Metric
        .gauge("present_proof_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.presentationBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val connectDidCommExchangesJob: RIO[
    AppConfig & DidOps & DIDResolver & HttpClient & ConnectionService & ManagedDIDService & DIDNonSecretStorage &
      WalletManagementService,
    Unit
  ] =
    for {
      config <- ZIO.service[AppConfig]
      _ <- (ConnectBackgroundJobs.didCommExchanges @@ Metric
        .gauge("connection_flow_did_com_exchange_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.connect.connectBgJobRecurrenceDelay))
        .unit
    } yield ()

  private val syncRevocationStatusListsJob = {
    for {
      config <- ZIO.service[AppConfig]
      _ <- (StatusListJobs.syncRevocationStatuses @@ Metric
        .gauge("revocation_status_list_sync_job_ms_gauge")
        .trackDurationWith(_.toMetricsSeconds))
        .repeat(Schedule.spaced(config.pollux.syncRevocationStatusesBgJobRecurrenceDelay))
    } yield ()
  }

  private val syncDIDPublicationStateFromDltJob: URIO[ManagedDIDService & WalletManagementService, Unit] =
    ZIO
      .serviceWithZIO[WalletManagementService](_.listWallets().map(_._1))
      .flatMap { wallets =>
        ZIO.foreach(wallets) { wallet =>
          DIDStateSyncBackgroundJobs.syncDIDPublicationStateFromDlt
            .provideSomeLayer(ZLayer.succeed(WalletAccessContext(wallet.id)))
        }
      }
      .catchAll(e => ZIO.logError(s"error while syncing DID publication state: $e"))
      .repeat(Schedule.spaced(10.seconds))
      .unit
      .provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))

}

object AgentHttpServer {
  val agentRESTServiceEndpoints = for {
    allCredentialDefinitionRegistryEndpoints <- CredentialDefinitionRegistryServerEndpoints.all
    allSchemaRegistryEndpoints <- SchemaRegistryServerEndpoints.all
    allVerificationPolicyEndpoints <- VerificationPolicyServerEndpoints.all
    allConnectionEndpoints <- ConnectionServerEndpoints.all
    allIssueEndpoints <- IssueServerEndpoints.all
    allStatusListEndpoints <- CredentialStatusServiceEndpoints.all
    allDIDEndpoints <- DIDServerEndpoints.all
    allDIDRegistrarEndpoints <- DIDRegistrarServerEndpoints.all
    allPresentProofEndpoints <- PresentProofServerEndpoints.all
    allVcVerificationEndpoints <- VcVerificationServerEndpoints.all
    allSystemEndpoints <- SystemServerEndpoints.all
    allEntityEndpoints <- EntityServerEndpoints.all
    allWalletManagementEndpoints <- WalletManagementServerEndpoints.all
    allEventEndpoints <- EventServerEndpoints.all
    allOIDCEndpoints <- CredentialIssuerServerEndpoints.all
    allPresentationExchangeEndpoints <- PresentationExchangeServerEndpoints.all
  } yield allCredentialDefinitionRegistryEndpoints ++
    allSchemaRegistryEndpoints ++
    allVerificationPolicyEndpoints ++
    allConnectionEndpoints ++
    allDIDEndpoints ++
    allDIDRegistrarEndpoints ++
    allIssueEndpoints ++
    allStatusListEndpoints ++
    allPresentProofEndpoints ++
    allVcVerificationEndpoints ++
    allPresentationExchangeEndpoints ++
    allSystemEndpoints ++
    allEntityEndpoints ++
    allWalletManagementEndpoints ++
    allEventEndpoints ++
    allOIDCEndpoints

  def run =
    for {
      allEndpoints <- agentRESTServiceEndpoints
      allEndpointsWithDocumentation = ZHttpEndpoints.withDocumentations[Task](allEndpoints)
      server <- ZHttp4sBlazeServer.make("rest_api")
      appConfig <- ZIO.service[AppConfig]
      _ <- server.start(allEndpointsWithDocumentation, port = appConfig.agent.httpEndpoint.http.port).debug
    } yield ()
}

object AgentInitialization {

  private val defaultWalletId = WalletId.default
  private val defaultWallet = Wallet("default", defaultWalletId)
  private val defaultEntity = Entity.Default

  def run: RIO[AppConfig & WalletManagementService & EntityService & ApiKeyAuthenticator, Unit] =
    for {
      _ <- validateAppConfig
      _ <- initializeDefaultWallet
        .provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))
    } yield ()

  private val validateAppConfig =
    ZIO.serviceWithZIO[AppConfig](conf =>
      ZIO
        .fromEither(conf.validate)
        .mapError(msg => RuntimeException(s"Application configuration is invalid. $msg"))
    )

  private val initializeDefaultWallet =
    for {
      _ <- ZIO.logInfo("Initializing default wallet.")
      config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)
      walletService <- ZIO.service[WalletManagementService]
      isDefaultWalletEnabled = config.enabled
      isDefaultWalletExist <- walletService
        .findWallet(defaultWalletId)
        .map(_.isDefined)
      _ <- ZIO.logInfo(s"Default wallet not enabled.").when(!isDefaultWalletEnabled)
      _ <- ZIO.logInfo(s"Default wallet already exist.").when(isDefaultWalletExist)
      _ <- createDefaultWallet.when(isDefaultWalletEnabled && !isDefaultWalletExist)
    } yield ()

  private val createDefaultWallet =
    for {
      walletService <- ZIO.service[WalletManagementService]
      entityService <- ZIO.service[EntityService]
      apiKeyAuth <- ZIO.service[ApiKeyAuthenticator]
      config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)
      seed <- config.seed.fold(ZIO.none) { seedHex =>
        ZIO
          .fromTry(HexString.fromString(seedHex))
          .map(bytes => WalletSeed.fromByteArray(bytes.toByteArray).left.map(Exception(_)))
          .absolve
          .asSome
      }
      _ <- ZIO.logInfo(s"Default wallet seed is not provided. New seed will be generated.").when(seed.isEmpty)
      _ <- walletService
        .createWallet(defaultWallet, seed)
        .orDieAsUnmanagedFailure
      _ <- entityService.create(defaultEntity).orDieAsUnmanagedFailure
      _ <- apiKeyAuth.add(defaultEntity.id, config.authApiKey)
      _ <- config.webhookUrl.fold(ZIO.unit) { url =>
        val customHeaders = config.webhookApiKey.fold(Map.empty)(apiKey => Map("Authorization" -> s"Bearer $apiKey"))
        walletService
          .createWalletNotification(EventNotificationConfig(defaultWalletId, url, customHeaders))
          .orDieAsUnmanagedFailure
          .provide(ZLayer.succeed(WalletAccessContext(defaultWalletId)))
      }
    } yield ()

}

1	package org.hyperledger.identus.agent.server
2
3	import org.hyperledger.identus.agent.notification.WebhookPublisher
4	import org.hyperledger.identus.agent.server.config.AppConfig
5	import org.hyperledger.identus.agent.server.http.{ZHttp4sBlazeServer, ZHttpEndpoints}
6	import org.hyperledger.identus.agent.server.jobs.*
7	import org.hyperledger.identus.agent.walletapi.model.{Entity, Wallet, WalletSeed}
8	import org.hyperledger.identus.agent.walletapi.service.{EntityService, ManagedDIDService, WalletManagementService}
9	import org.hyperledger.identus.agent.walletapi.storage.DIDNonSecretStorage
10	import org.hyperledger.identus.castor.controller.{DIDRegistrarServerEndpoints, DIDServerEndpoints}
11	import org.hyperledger.identus.castor.core.service.DIDService
12	import org.hyperledger.identus.connect.controller.ConnectionServerEndpoints
13	import org.hyperledger.identus.connect.core.service.ConnectionService
14	import org.hyperledger.identus.credentialstatus.controller.CredentialStatusServiceEndpoints
15	import org.hyperledger.identus.event.controller.EventServerEndpoints
16	import org.hyperledger.identus.event.notification.EventNotificationConfig
17	import org.hyperledger.identus.iam.authentication.apikey.ApiKeyAuthenticator
18	import org.hyperledger.identus.iam.entity.http.EntityServerEndpoints
19	import org.hyperledger.identus.iam.wallet.http.WalletManagementServerEndpoints
20	import org.hyperledger.identus.issue.controller.IssueServerEndpoints
21	import org.hyperledger.identus.mercury.{DidOps, HttpClient}
22	import org.hyperledger.identus.oid4vci.CredentialIssuerServerEndpoints
23	import org.hyperledger.identus.pollux.core.service.{CredentialService, PresentationService}
24	import org.hyperledger.identus.pollux.credentialdefinition.CredentialDefinitionRegistryServerEndpoints
25	import org.hyperledger.identus.pollux.credentialschema.{
26	SchemaRegistryServerEndpoints,
27	VerificationPolicyServerEndpoints
28	}
29	import org.hyperledger.identus.pollux.prex.PresentationExchangeServerEndpoints
30	import org.hyperledger.identus.pollux.vc.jwt.DidResolver as JwtDidResolver
31	import org.hyperledger.identus.presentproof.controller.PresentProofServerEndpoints
32	import org.hyperledger.identus.resolvers.DIDResolver
33	import org.hyperledger.identus.shared.http.UriResolver
34	import org.hyperledger.identus.shared.models.{HexString, WalletAccessContext, WalletAdministrationContext, WalletId}
35	import org.hyperledger.identus.shared.utils.DurationOps.toMetricsSeconds
36	import org.hyperledger.identus.system.controller.SystemServerEndpoints
37	import org.hyperledger.identus.verification.controller.VcVerificationServerEndpoints
38	import zio.*
39	import zio.metrics.*
40
41	object CloudAgentApp {
42
43	def run = for {	×
44	_ <- AgentInitialization.run	×
45	_ <- issueCredentialDidCommExchangesJob.debug.fork	×
46	_ <- presentProofExchangeJob.debug.fork	×
47	_ <- connectDidCommExchangesJob.debug.fork	×
48	_ <- syncDIDPublicationStateFromDltJob.debug.fork	×
49	_ <- syncRevocationStatusListsJob.debug.fork	×
50	_ <- AgentHttpServer.run.tapDefect(e => ZIO.logErrorCause("Agent HTTP Server failure", e)).fork	×
51	fiber <- DidCommHttpServer.run.tapDefect(e => ZIO.logErrorCause("DIDComm HTTP Server failure", e)).fork	×
52	_ <- WebhookPublisher.layer.build.map(_.get[WebhookPublisher]).flatMap(_.run.fork)	×
53	_ <- fiber.join *> ZIO.log(s"Server End")	×
54	_ <- ZIO.never	×
55	} yield ()	×
56
57	private val issueCredentialDidCommExchangesJob: RIO[
58	AppConfig & DidOps & DIDResolver & JwtDidResolver & HttpClient & CredentialService & DIDNonSecretStorage &
59	DIDService & ManagedDIDService & PresentationService & WalletManagementService,
60	Unit
61	] =
62	for {	×
63	config <- ZIO.service[AppConfig]	×
64	_ <- (IssueBackgroundJobs.issueCredentialDidCommExchanges @@ Metric	×
65	.gauge("issuance_flow_did_com_exchange_job_ms_gauge")	×
66	.trackDurationWith(_.toMetricsSeconds))	×
67	.repeat(Schedule.spaced(config.pollux.issueBgJobRecurrenceDelay))	×
68	.unit
69	} yield ()	×
70
71	private val presentProofExchangeJob: RIO[
72	AppConfig & DidOps & UriResolver & DIDResolver & JwtDidResolver & HttpClient & PresentationService &
73	CredentialService & DIDNonSecretStorage & DIDService & ManagedDIDService,
74	Unit
75	] =
76	for {	×
77	config <- ZIO.service[AppConfig]	×
78	_ <- (PresentBackgroundJobs.presentProofExchanges @@ Metric	×
79	.gauge("present_proof_flow_did_com_exchange_job_ms_gauge")	×
80	.trackDurationWith(_.toMetricsSeconds))	×
81	.repeat(Schedule.spaced(config.pollux.presentationBgJobRecurrenceDelay))	×
82	.unit
83	} yield ()	×
84
85	private val connectDidCommExchangesJob: RIO[
86	AppConfig & DidOps & DIDResolver & HttpClient & ConnectionService & ManagedDIDService & DIDNonSecretStorage &
87	WalletManagementService,
88	Unit
89	] =
90	for {	×
91	config <- ZIO.service[AppConfig]	×
92	_ <- (ConnectBackgroundJobs.didCommExchanges @@ Metric	×
93	.gauge("connection_flow_did_com_exchange_job_ms_gauge")	×
94	.trackDurationWith(_.toMetricsSeconds))	×
95	.repeat(Schedule.spaced(config.connect.connectBgJobRecurrenceDelay))	×
96	.unit
97	} yield ()	×
98
99	private val syncRevocationStatusListsJob = {
100	for {	×
101	config <- ZIO.service[AppConfig]	×
102	_ <- (StatusListJobs.syncRevocationStatuses @@ Metric	×
103	.gauge("revocation_status_list_sync_job_ms_gauge")	×
104	.trackDurationWith(_.toMetricsSeconds))	×
105	.repeat(Schedule.spaced(config.pollux.syncRevocationStatusesBgJobRecurrenceDelay))	×
106	} yield ()	×
107	}
108
109	private val syncDIDPublicationStateFromDltJob: URIO[ManagedDIDService & WalletManagementService, Unit] =
110	ZIO	×
111	.serviceWithZIO[WalletManagementService](_.listWallets().map(_._1))	×
112	.flatMap { wallets =>
113	ZIO.foreach(wallets) { wallet =>	×
114	DIDStateSyncBackgroundJobs.syncDIDPublicationStateFromDlt	×
115	.provideSomeLayer(ZLayer.succeed(WalletAccessContext(wallet.id)))	×
116	}
117	}
118	.catchAll(e => ZIO.logError(s"error while syncing DID publication state: $e"))	×
119	.repeat(Schedule.spaced(10.seconds))	×
120	.unit
121	.provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))	×
122
123	}
124
125	object AgentHttpServer {
126	val agentRESTServiceEndpoints = for {	×
127	allCredentialDefinitionRegistryEndpoints <- CredentialDefinitionRegistryServerEndpoints.all	×
128	allSchemaRegistryEndpoints <- SchemaRegistryServerEndpoints.all	×
129	allVerificationPolicyEndpoints <- VerificationPolicyServerEndpoints.all	×
130	allConnectionEndpoints <- ConnectionServerEndpoints.all	×
131	allIssueEndpoints <- IssueServerEndpoints.all	×
132	allStatusListEndpoints <- CredentialStatusServiceEndpoints.all	×
133	allDIDEndpoints <- DIDServerEndpoints.all	×
134	allDIDRegistrarEndpoints <- DIDRegistrarServerEndpoints.all	×
135	allPresentProofEndpoints <- PresentProofServerEndpoints.all	×
136	allVcVerificationEndpoints <- VcVerificationServerEndpoints.all	×
137	allSystemEndpoints <- SystemServerEndpoints.all	×
138	allEntityEndpoints <- EntityServerEndpoints.all	×
139	allWalletManagementEndpoints <- WalletManagementServerEndpoints.all	×
140	allEventEndpoints <- EventServerEndpoints.all	×
141	allOIDCEndpoints <- CredentialIssuerServerEndpoints.all	×
142	allPresentationExchangeEndpoints <- PresentationExchangeServerEndpoints.all	×
143	} yield allCredentialDefinitionRegistryEndpoints ++	×
144	allSchemaRegistryEndpoints ++
145	allVerificationPolicyEndpoints ++
146	allConnectionEndpoints ++
147	allDIDEndpoints ++
148	allDIDRegistrarEndpoints ++
149	allIssueEndpoints ++
150	allStatusListEndpoints ++
151	allPresentProofEndpoints ++
152	allVcVerificationEndpoints ++
153	allPresentationExchangeEndpoints ++
154	allSystemEndpoints ++
155	allEntityEndpoints ++
156	allWalletManagementEndpoints ++
157	allEventEndpoints ++
158	allOIDCEndpoints
159
160	def run =	×
161	for {	×
162	allEndpoints <- agentRESTServiceEndpoints	×
163	allEndpointsWithDocumentation = ZHttpEndpoints.withDocumentations[Task](allEndpoints)	×
164	server <- ZHttp4sBlazeServer.make("rest_api")	×
165	appConfig <- ZIO.service[AppConfig]	×
166	_ <- server.start(allEndpointsWithDocumentation, port = appConfig.agent.httpEndpoint.http.port).debug	×
167	} yield ()	×
168	}
169
170	object AgentInitialization {
171
172	private val defaultWalletId = WalletId.default	1✔
173	private val defaultWallet = Wallet("default", defaultWalletId)	1✔
174	private val defaultEntity = Entity.Default
175
176	def run: RIO[AppConfig & WalletManagementService & EntityService & ApiKeyAuthenticator, Unit] =	1✔
177	for {	1✔
178	_ <- validateAppConfig
179	_ <- initializeDefaultWallet	1✔
180	.provideSomeLayer(ZLayer.succeed(WalletAdministrationContext.Admin()))	1✔
181	} yield ()	1✔
182
183	private val validateAppConfig =
184	ZIO.serviceWithZIO[AppConfig](conf =>	1✔
185	ZIO	1✔
186	.fromEither(conf.validate)	1✔
187	.mapError(msg => RuntimeException(s"Application configuration is invalid. $msg"))	1✔
188	)
189
190	private val initializeDefaultWallet =
191	for {	1✔
192	_ <- ZIO.logInfo("Initializing default wallet.")	1✔
193	config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)	1✔
194	walletService <- ZIO.service[WalletManagementService]	1✔
195	isDefaultWalletEnabled = config.enabled
196	isDefaultWalletExist <- walletService	1✔
197	.findWallet(defaultWalletId)	1✔
198	.map(_.isDefined)	1✔
UNCOV 199	_ <- ZIO.logInfo(s"Default wallet not enabled.").when(!isDefaultWalletEnabled)	×
200	_ <- ZIO.logInfo(s"Default wallet already exist.").when(isDefaultWalletExist)	×
201	_ <- createDefaultWallet.when(isDefaultWalletEnabled && !isDefaultWalletExist)	1✔
202	} yield ()	1✔
203
204	private val createDefaultWallet =
205	for {	1✔
206	walletService <- ZIO.service[WalletManagementService]	1✔
207	entityService <- ZIO.service[EntityService]	1✔
208	apiKeyAuth <- ZIO.service[ApiKeyAuthenticator]	1✔
209	config <- ZIO.serviceWith[AppConfig](_.agent.defaultWallet)	1✔
210	seed <- config.seed.fold(ZIO.none) { seedHex =>	1✔
211	ZIO	1✔
212	.fromTry(HexString.fromString(seedHex))	1✔
UNCOV 213	.map(bytes => WalletSeed.fromByteArray(bytes.toByteArray).left.map(Exception(_)))	×
214	.absolve
215	.asSome
216	}
217	_ <- ZIO.logInfo(s"Default wallet seed is not provided. New seed will be generated.").when(seed.isEmpty)	1✔
218	_ <- walletService	1✔
219	.createWallet(defaultWallet, seed)	1✔
220	.orDieAsUnmanagedFailure	1✔
221	_ <- entityService.create(defaultEntity).orDieAsUnmanagedFailure	1✔
222	_ <- apiKeyAuth.add(defaultEntity.id, config.authApiKey)	1✔
223	_ <- config.webhookUrl.fold(ZIO.unit) { url =>	1✔
224	val customHeaders = config.webhookApiKey.fold(Map.empty)(apiKey => Map("Authorization" -> s"Bearer $apiKey"))	1✔
225	walletService
226	.createWalletNotification(EventNotificationConfig(defaultWalletId, url, customHeaders))	1✔
227	.orDieAsUnmanagedFailure	1✔
228	.provide(ZLayer.succeed(WalletAccessContext(defaultWalletId)))	1✔
229	}
230	} yield ()	1✔
231
232	}

hyperledger / identus-cloud-agent / 11056380298

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous