refactor: move BLS and KZG specific types to their specific modules

lib/bls.ex

@@ -5,48 +5,50 @@ defmodule Bls do
   use Rustler, otp_app: :lambda_ethereum_consensus, crate: "bls_nif"
 
   @type privkey() :: <<_::256>>
+  @type pubkey :: <<_::384>>
+  @type signature :: <<_::768>>
 
-  @spec sign(privkey(), binary()) :: {:ok, Types.bls_signature()} | {:error, any()}
+  @spec sign(privkey(), binary()) :: {:ok, signature()} | {:error, any()}
   def sign(_private_key, _message) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec aggregate([Types.bls_signature()]) :: {:ok, Types.bls_signature()} | {:error, any()}
+  @spec aggregate([signature()]) :: {:ok, signature()} | {:error, any()}
   def aggregate(_signatures) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec verify(Types.bls_pubkey(), binary(), Types.bls_signature()) ::
+  @spec verify(pubkey(), binary(), signature()) ::
           {:ok, boolean} | {:error, binary()}
   def verify(_public_key, _message, _signature) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec fast_aggregate_verify([Types.bls_pubkey()], binary(), Types.bls_signature()) ::
+  @spec fast_aggregate_verify([pubkey()], binary(), signature()) ::
           {:ok, boolean} | {:error, binary()}
   def fast_aggregate_verify(_public_keys, _message, _signature) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec eth_fast_aggregate_verify([Types.bls_pubkey()], binary(), Types.bls_signature()) ::
+  @spec eth_fast_aggregate_verify([pubkey()], binary(), signature()) ::
           {:ok, boolean} | {:error, binary()}
   def eth_fast_aggregate_verify(_public_keys, _message, _signature) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec aggregate_verify([Types.bls_pubkey()], [binary()], Types.bls_signature()) ::
+  @spec aggregate_verify([pubkey()], [binary()], signature()) ::
           {:ok, boolean} | {:error, binary()}
   def aggregate_verify(_public_keys, _messages, _signature) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec eth_aggregate_pubkeys([Types.bls_pubkey()]) ::
-          {:ok, Types.bls_pubkey()} | {:error, any()}
+  @spec eth_aggregate_pubkeys([pubkey()]) ::
+          {:ok, pubkey()} | {:error, any()}
   def eth_aggregate_pubkeys(_public_keys) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec key_validate(Types.bls_pubkey()) ::
+  @spec key_validate(pubkey()) ::
           {:ok, boolean} | {:error, binary()}
   def key_validate(_public_key) do
     :erlang.nif_error(:nif_not_loaded)
@@ -56,7 +58,7 @@ defmodule Bls do
   @doc """
   Same as ``Bls.verify``, but treats errors as invalid signatures.
   """
-  @spec valid?(Types.bls_pubkey(), binary(), Types.bls_signature()) :: boolean()
+  @spec valid?(pubkey(), binary(), signature()) :: boolean()
   def valid?(public_key, message, signature) do
     case Bls.verify(public_key, message, signature) do
       {:ok, bool} -> bool
@@ -68,7 +70,7 @@ defmodule Bls do
   @doc """
   Same as ``Bls.fast_aggregate_verify``, but treats errors as invalid signatures.
   """
-  @spec fast_aggregate_valid?([Types.bls_pubkey()], binary(), Types.bls_signature()) :: boolean()
+  @spec fast_aggregate_valid?([pubkey()], binary(), signature()) :: boolean()
   def fast_aggregate_valid?(public_keys, message, signature) do
     case Bls.fast_aggregate_verify(public_keys, message, signature) do
       {:ok, bool} -> bool

lib/kzg.ex

@@ -4,44 +4,47 @@ defmodule Kzg do
   """
   use Rustler, otp_app: :lambda_ethereum_consensus, crate: "kzg_nif"
 
-  @spec blob_to_kzg_commitment(Types.blob()) :: {:ok, Types.kzg_commitment()} | {:error, binary()}
+  @type commitment :: <<_::384>>
+  @type proof :: <<_::768>>
+
+  @spec blob_to_kzg_commitment(Types.blob()) :: {:ok, commitment()} | {:error, binary()}
   def blob_to_kzg_commitment(_blob) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
   @spec compute_kzg_proof(Types.blob(), Types.bytes32()) ::
-          {:ok, {Types.kzg_proof(), Types.bytes32()}} | {:error, binary()}
+          {:ok, {proof(), Types.bytes32()}} | {:error, binary()}
   def compute_kzg_proof(_blob, _z) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
   @spec verify_kzg_proof(
-          Types.kzg_commitment(),
+          commitment(),
           Types.bytes32(),
           Types.bytes32(),
-          Types.kzg_proof()
+          proof()
         ) ::
           {:ok, boolean} | {:error, binary()}
   def verify_kzg_proof(_kzg_commitment, _z, _y, _kzg_proof) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec compute_blob_kzg_proof(Types.blob(), Types.kzg_commitment()) ::
-          {:ok, Types.kzg_proof()} | {:error, binary()}
+  @spec compute_blob_kzg_proof(Types.blob(), commitment()) ::
+          {:ok, proof()} | {:error, binary()}
   def compute_blob_kzg_proof(_blob, _kzg_commitment) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
-  @spec verify_blob_kzg_proof(Types.blob(), Types.kzg_commitment(), Types.kzg_proof()) ::
+  @spec verify_blob_kzg_proof(Types.blob(), commitment(), proof()) ::
           {:ok, boolean} | {:error, binary()}
   def verify_blob_kzg_proof(_blob, _kzg_commitment, _kzg_proof) do
     :erlang.nif_error(:nif_not_loaded)
   end
 
   @spec verify_blob_kzg_proof_batch(
           list(Types.blob()),
-          list(Types.kzg_commitment()),
-          list(Types.kzg_proof())
+          list(commitment()),
+          list(proof())
         ) ::
           {:ok, boolean} | {:error, binary()}
   def verify_blob_kzg_proof_batch(_blobs, _kzg_commitments, _kzg_proofs) do
@@ -54,8 +57,8 @@ defmodule Kzg do
 
   @spec blob_kzg_proof_batch_valid?(
           list(Types.blob()),
-          list(Types.kzg_commitment()),
-          list(Types.kzg_proof())
+          list(commitment()),
+          list(proof())
         ) :: boolean()
   def blob_kzg_proof_batch_valid?(blobs, kzg_commitments, kzg_proofs) do
     case verify_blob_kzg_proof_batch(blobs, kzg_commitments, kzg_proofs) do

lib/types/types.ex

@@ -35,8 +35,6 @@ defmodule Types do
   @type domain_type :: bytes4
   @type fork_digest :: bytes4
   @type domain :: bytes32
-  @type bls_pubkey :: bytes48
-  @type bls_signature :: bytes96
   @type participation_flags :: uint8
   # Max size: 2**30
   @type transaction :: binary
@@ -46,6 +44,8 @@ defmodule Types do
   @type blob_index :: uint64
   # Max size: BYTES_PER_FIELD_ELEMENT * FIELD_ELEMENTS_PER_BLOB
   @type blob :: binary
-  @type kzg_commitment :: bytes48
-  @type kzg_proof :: bytes48
+  @type kzg_commitment :: Kzg.commitment()
+  @type kzg_proof :: Kzg.proof()
+  @type bls_signature :: Bls.signature()
+  @type bls_pubkey :: Bls.pubkey()
 end