954161a5b397cc94069ec938dc16fcb785e37074-PR-29

Committed 18 Jan 2025 10:28PM UTC coverage: 85.651% (-4.3%) from 89.944%

Build # 954161a5b397cc94069ec938dc16fcb785e37074-PR-29

Build Type

Pull #29

github

Committed by

patatoid

Commit Message

refactor verifiable credentials status tokens

Pull Request Pull Request #29: Agent credentials PoC

Run Details

188 of 304 new or added lines in 20 files covered. (61.84%)

3 existing lines in 1 file now uncovered.

1552 of 1812 relevant lines covered (85.65%)

85.85 hits per line

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

21.74

/lib/boruta/did.ex

defmodule Boruta.Did do
  # TODO integration tests
  @moduledoc """
    Utilities to manipulate dids using an universal resolver or registrar.
  """

  import Boruta.Config,
    only: [
      universal_did_auth: 0,
      ebsi_did_resolver_base_url: 0,
      did_resolver_base_url: 0,
      did_registrar_base_url: 0
    ]

  @spec resolve(did :: String.t()) ::
          {:ok, did_document :: map()} | {:error, reason :: String.t()}
  def resolve("did:ebsi" <> _key = did) do
    resolver_url = "#{ebsi_did_resolver_base_url()}/identifiers/#{did}"

    case Finch.build(:get, resolver_url)
         |> Finch.request(OpenIDHttpClient) do
      {:ok, %Finch.Response{body: body, status: 200}} ->
        case Jason.decode(body) do
          {:ok, %{"didDocument" => did_document}} ->
            {:ok, did_document}

          {:ok, did_document} ->
            {:ok, did_document}

          {:error, error} ->
            {:error, error}
        end

      {:ok, %Finch.Response{body: body}} ->
        {:error, body}

      {:error, error} ->
        {:error, inspect(error)}
    end
  end

  def resolve(did) do
    resolver_url = "#{did_resolver_base_url()}/identifiers/#{did}"

    with {:ok, %Finch.Response{body: body, status: 200}} <-
           Finch.build(:get, resolver_url, [
             {"Authorization", "Bearer #{universal_did_auth()[:token]}"}
           ])
           |> Finch.request(OpenIDHttpClient),
         {:ok, %{"didDocument" => did_document}} <- Jason.decode(body) do
      {:ok, did_document}
    else
      {:ok, %Finch.Response{body: body}} ->
        {:error, body}

      {:error, error} ->
        {:error, inspect(error)}

      {:ok, response} ->
        {:error, "Invalid resolver response: \"#{inspect(response)}\""}
    end
  end

  @dialyzer {:no_return, create: 1}
  @dialyzer {:no_return, create: 2}
  @spec create(method :: String.t()) ::
          {:ok, did :: String.t(), jwk :: map()} | {:error, reason :: String.t()}
  @spec create(method :: String.t(), jwk :: map() | nil) ::
          {:ok, did :: String.t(), jwk :: map()} | {:error, reason :: String.t()}
  def create("key" = method, jwk \\ nil) do
    payload = %{
      "didDocument" => %{
        "@context" => ["https//www.w3.org/ns/did/v1"],
        "service" => []
      },
      "secret" => %{}
    }

    payload =
      case jwk do
        nil ->
          payload
          |> Map.put("options", %{
            "keyType" => "Ed25519",
            "jwkJcsPub" => true
          })

        jwk ->
          Map.put(payload, "didDocument", %{
            "@context" => ["https//www.w3.org/ns/did/v1"],
            "service" => [],
            "verificationMethod" => [
              %{
                "id" => "#temp",
                "type" => "JsonWebKey2020",
                "publicKeyJwk" => jwk
              }
            ]
          })
          |> Map.put("options", %{
            "keyType" => "Ed25519",
            "clientSecretMode" => true,
            "jwkJcsPub" => true
          })
      end

    with {:ok, %Finch.Response{status: 201, body: body}} <-
           Finch.build(
             :post,
             did_registrar_base_url() <> "/create?method=#{method}",
             [
               {"Authorization", "Bearer #{universal_did_auth()[:token]}"},
               {"Content-Type", "application/json"}
             ],
             Jason.encode!(payload)
           )
           |> Finch.request(OpenIDHttpClient),
         %{
           "didState" => %{
             "did" => did,
             "didDocument" => %{"verificationMethod" => [%{"publicKeyJwk" => jwk}]}
           }
         } <- Jason.decode!(body) do
      {:ok, did, jwk}
    else
      _ ->
        {:error, "Could not create did."}
    end
  end

  @spec controller(did :: String.t() | nil) :: controller :: String.t() | nil
  def controller(nil), do: nil
  def controller(did), do: String.split(did, "#") |> List.first()
end

1	defmodule Boruta.Did do
2	# TODO integration tests
3	@moduledoc """
4	Utilities to manipulate dids using an universal resolver or registrar.
5	"""
6
7	import Boruta.Config,
8	only: [
9	universal_did_auth: 0,
10	ebsi_did_resolver_base_url: 0,
11	did_resolver_base_url: 0,
12	did_registrar_base_url: 0
13	]
14
15	@spec resolve(did :: String.t()) ::
16	{:ok, did_document :: map()} \| {:error, reason :: String.t()}
17	def resolve("did:ebsi" <> _key = did) do
18	resolver_url = "#{ebsi_did_resolver_base_url()}/identifiers/#{did}"	×
19
20	case Finch.build(:get, resolver_url)	×
21	\|> Finch.request(OpenIDHttpClient) do
22	{:ok, %Finch.Response{body: body, status: 200}} ->
23	case Jason.decode(body) do	×
24	{:ok, %{"didDocument" => did_document}} ->	×
25	{:ok, did_document}
26
UNCOV 27	{:ok, did_document} ->	×
28	{:ok, did_document}
29
UNCOV 30	{:error, error} ->	×
31	{:error, error}
32	end
33
34	{:ok, %Finch.Response{body: body}} ->	×
35	{:error, body}
36
37	{:error, error} ->	×
38	{:error, inspect(error)}
39	end
40	end
41
42	def resolve(did) do
43	resolver_url = "#{did_resolver_base_url()}/identifiers/#{did}"	25✔
44
45	with {:ok, %Finch.Response{body: body, status: 200}} <-	25✔
46	Finch.build(:get, resolver_url, [
47	{"Authorization", "Bearer #{universal_did_auth()[:token]}"}	25✔
48	])
49	\|> Finch.request(OpenIDHttpClient),
50	{:ok, %{"didDocument" => did_document}} <- Jason.decode(body) do	25✔
51	{:ok, did_document}
52	else
53	{:ok, %Finch.Response{body: body}} ->
54	{:error, body}
55
56	{:error, error} ->
57	{:error, inspect(error)}
58
59	{:ok, response} ->
60	{:error, "Invalid resolver response: \"#{inspect(response)}\""}
61	end
62	end
63
64	@dialyzer {:no_return, create: 1}
65	@dialyzer {:no_return, create: 2}
66	@spec create(method :: String.t()) ::
67	{:ok, did :: String.t(), jwk :: map()} \| {:error, reason :: String.t()}
68	@spec create(method :: String.t(), jwk :: map() \| nil) ::
69	{:ok, did :: String.t(), jwk :: map()} \| {:error, reason :: String.t()}
70	def create("key" = method, jwk \\ nil) do
UNCOV 71	payload = %{	×
72	"didDocument" => %{
73	"@context" => ["https//www.w3.org/ns/did/v1"],
74	"service" => []
75	},
76	"secret" => %{}
77	}
78
NEW 79	payload =	×
80	case jwk do
81	nil ->
82	payload
NEW 83	\|> Map.put("options", %{	×
84	"keyType" => "Ed25519",
85	"jwkJcsPub" => true
86	})
87
88	jwk ->
89	Map.put(payload, "didDocument", %{
90	"@context" => ["https//www.w3.org/ns/did/v1"],
91	"service" => [],
92	"verificationMethod" => [
93	%{
94	"id" => "#temp",
95	"type" => "JsonWebKey2020",
96	"publicKeyJwk" => jwk
97	}
98	]
99	})
NEW 100	\|> Map.put("options", %{	×
101	"keyType" => "Ed25519",
102	"clientSecretMode" => true,
103	"jwkJcsPub" => true
104	})
105	end
106
NEW 107	with {:ok, %Finch.Response{status: 201, body: body}} <-	×
108	Finch.build(
109	:post,
NEW 110	did_registrar_base_url() <> "/create?method=#{method}",	×
111	[
NEW 112	{"Authorization", "Bearer #{universal_did_auth()[:token]}"},	×
113	{"Content-Type", "application/json"}
114	],
115	Jason.encode!(payload)
116	)
117	\|> Finch.request(OpenIDHttpClient),
118	%{
119	"didState" => %{
120	"did" => did,
121	"didDocument" => %{"verificationMethod" => [%{"publicKeyJwk" => jwk}]}
122	}
NEW 123	} <- Jason.decode!(body) do	×
NEW 124	{:ok, did, jwk}	×
125	else
126	_ ->
127	{:error, "Could not create did."}
128	end
129	end
130
131	@spec controller(did :: String.t() \| nil) :: controller :: String.t() \| nil
132	def controller(nil), do: nil	29✔
NEW 133	def controller(did), do: String.split(did, "#") \|> List.first()	×
134	end

malach-it / boruta_auth / 954161a5b397cc94069ec938dc16fcb785e37074-PR-29

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