5505123938

Committed 10 Jul 2023 07:08AM UTC coverage: 28.371% (+0.3%) from 28.076%

Build Type

Committed by

Commit Message

feat: add event type field to all events

Pull Request Pull Request #575: feat(prism-agent): simple event mechanism using webhook

Run Details

384 of 384 new or added lines in 15 files covered. (100.0%)

2756 of 9714 relevant lines covered (28.37%)

0.28 hits per line

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

40.0

/prism-agent/service/wallet-api/src/main/scala/io/iohk/atala/agent/walletapi/util/SeedResolver.scala

package io.iohk.atala.agent.walletapi.util

import zio.*
import io.iohk.atala.shared.models.HexString
import io.iohk.atala.agent.walletapi.crypto.Apollo

trait SeedResolver {
  def resolve: Task[Array[Byte]]
}

object SeedResolver {
  def layer(isDevMode: Boolean = false): URLayer[Apollo, SeedResolver] =
    ZLayer.fromFunction(SeedResolverImpl(_, isDevMode))
}

private class SeedResolverImpl(apollo: Apollo, isDevMode: Boolean) extends SeedResolver {
  override def resolve: Task[Array[Byte]] = {
    val seedEnv =
      for {
        _ <- ZIO.logInfo("Resolving a wallet seed using WALLET_SEED environemnt variable")
        maybeSeed <- System
          .env("WALLET_SEED")
          .flatMap {
            case Some(hex) => ZIO.fromTry(HexString.fromString(hex)).map(_.toByteArray).asSome
            case None      => ZIO.none
          }
          .tapError(e =>
            ZIO.logError(
              "Failed to parse WALLET_SEED. The WALLET_SEED must be a hex string representing 64-bytes (128-characters) BIP39 seed"
            )
          )
        _ <- ZIO.logInfo("WALLET_SEED environment is not found.").when(maybeSeed.isEmpty)
        // When DEV_MODE=fase, the WALLET_SEED must be set.
        _ <- ZIO
          .fail(Exception("WALLET_SEED must be present when running with DEV_MODE=false"))
          .when(maybeSeed.isEmpty && !isDevMode)
      } yield maybeSeed

    val seedRand =
      for {
        _ <- ZIO.logInfo("Generating a new wallet seed")
        seedWithMnemonic <- apollo.ecKeyFactory.randomBip32Seed()
        (seed, mnemonic) = seedWithMnemonic
        seedHex = HexString.fromByteArray(seed)
        _ <- ZIO
          .logInfo(s"New seed generated : $seedHex (${mnemonic.mkString("[", ", ", "]")})")
          .when(isDevMode)
      } yield seed

    seedEnv
      .flatMap {
        case Some(seed) => ZIO.succeed(seed)
        case None       => seedRand
      }
      .tap(seed =>
        ZIO
          .fromEither(validateSeed(seed))
          .tapError(e => ZIO.logError(e))
          .mapError(Exception(_))
      )
  }

  private def validateSeed(seed: Array[Byte]): Either[String, Unit] = {
    if (seed.length != 64) Left(s"The seed must be 64-bytes (got ${seed.length} bytes)")
    else Right(())
  }

}

1	package io.iohk.atala.agent.walletapi.util
2
3	import zio.*
4	import io.iohk.atala.shared.models.HexString
5	import io.iohk.atala.agent.walletapi.crypto.Apollo
6
7	trait SeedResolver {
8	def resolve: Task[Array[Byte]]
9	}
10
11	object SeedResolver {	1✔
12	def layer(isDevMode: Boolean = false): URLayer[Apollo, SeedResolver] =	1✔
13	ZLayer.fromFunction(SeedResolverImpl(_, isDevMode))
14	}
15
16	private class SeedResolverImpl(apollo: Apollo, isDevMode: Boolean) extends SeedResolver {	1✔
17	override def resolve: Task[Array[Byte]] = {
18	val seedEnv =	1✔
19	for {	×
20	_ <- ZIO.logInfo("Resolving a wallet seed using WALLET_SEED environemnt variable")	×
21	maybeSeed <- System
22	.env("WALLET_SEED")
23	.flatMap {	×
24	case Some(hex) => ZIO.fromTry(HexString.fromString(hex)).map(_.toByteArray).asSome	×
25	case None => ZIO.none
26	}
27	.tapError(e =>	×
28	ZIO.logError(
29	"Failed to parse WALLET_SEED. The WALLET_SEED must be a hex string representing 64-bytes (128-characters) BIP39 seed"
30	)
31	)	1✔
32	_ <- ZIO.logInfo("WALLET_SEED environment is not found.").when(maybeSeed.isEmpty)
33	// When DEV_MODE=fase, the WALLET_SEED must be set.	×
34	_ <- ZIO	×
35	.fail(Exception("WALLET_SEED must be present when running with DEV_MODE=false"))	×
36	.when(maybeSeed.isEmpty && !isDevMode)
37	} yield maybeSeed
38
39	val seedRand =	1✔
40	for {	×
41	_ <- ZIO.logInfo("Generating a new wallet seed")	×
42	seedWithMnemonic <- apollo.ecKeyFactory.randomBip32Seed()	×
43	(seed, mnemonic) = seedWithMnemonic	×
44	seedHex = HexString.fromByteArray(seed)	1✔
45	_ <- ZIO	×
46	.logInfo(s"New seed generated : $seedHex (${mnemonic.mkString("[", ", ", "]")})")
47	.when(isDevMode)
48	} yield seed
49		1✔
50	seedEnv
51	.flatMap {	×
52	case Some(seed) => ZIO.succeed(seed)	×
53	case None => seedRand
54	}
55	.tap(seed =>	×
56	ZIO	×
57	.fromEither(validateSeed(seed))	×
58	.tapError(e => ZIO.logError(e))	1✔
59	.mapError(Exception(_))
60	)
61	}
62		1✔
63	private def validateSeed(seed: Array[Byte]): Either[String, Unit] = {	1✔
64	if (seed.length != 64) Left(s"The seed must be 64-bytes (got ${seed.length} bytes)")	1✔
65	else Right(())
66	}
67
68	}

input-output-hk / atala-prism-building-blocks / 5505123938

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