Wondering how to best form this function that does multiple checks

yreuvekamp

I’m writing a function that does some simple checks to see if a (crypto) wallet address can be considered valid for the specific network (validity of this aside; it’s more of a quick check to catch mistakes)

What I need to check:

Bech32 decode the provided address
This should result in a human-readable part (hrp) and a public key
The human-readable part should be either “rdx” or “tdx”
The total length of the public key should be 34
The first byte of the public key should be 4
The second byte of the public key should be 2 or 3

I’ve had multiple variations of this and none of them feel right. I was wondering if any of you had some suggestions on how to best write this function.

This is what I had first:

  def is_valid_wallet?(wallet_address) do
    {:ok, hrp, <<first_byte, second_byte, _rest::binary-size(32)>>} =
      Bech32.decode(wallet_address)

    if hrp in ["rdx", "tdx"] and first_byte == 4 and second_byte in [2, 3] do
      true
    else
      false
    end
  end

Problem with that is that I want to return true or false, and the pattern match might already return an error and I’m not handling that case. Adding the handling for that feels like I’m doing double work.

This is what I have now:

  def is_valid_wallet?(wallet_address) do
    case Bech32.decode(wallet_address) do
      {:ok, hrp, <<first_byte, second_byte, _rest::binary-size(32)>>}
      when hrp in ["rdx", "tdx"] and first_byte == 4 and second_byte in [2, 3] ->
        true

      _ ->
        false
     end
  end

This will return true or false, but it looks messy to me

Looking forward to hearing your suggestions.

3 comments

#idiomatic-elixir

0 702 3

2022-01-10 17:17:04 UTC

Showing Posts 1 to 3

Show Best Posts
Show All (oldest first)
Show All (newest first)

al2o3cr

Regrouping the steps like this:

Bech32 decode the provided address
This should result in a human-readable part (hrp) and a public key
The human-readable part should be either “rdx” or “tdx”
The public key should be valid
- the total length of the public key should be 34
- the first byte of the public key should be 4
- the second byte of the public key should be 2 or 3

Gives code like this:

def is_valid_wallet?(wallet_address) do
  {:ok, hrp, pk} = Bech32.decode(wallet_address)

  hrp in ["rdx", "tdx"] and valid_public_key?(pk)
end

defp valid_public_key?(<<4, second, _rest::binary-size(32)>>) when second in [2, 3], do: true
defp valid_public_key?(_), do: false

Post #1

yreuvekamp

That looks loads better, thanks! As far as I’m concerned I’m marking it as the solution, but if others want to pitch in, go ahead

Post #2

stevensonmt

Might be a good candidate for a with statement:

def is_valid_wallet?(wallet_address) do
  with {:ok, hrp, pk} <- Bech32.decode(wallet_address),
    true <- hrp in ["rdx", "tdx"] 
  do
    valid_public_key?(pk)
  else
    _ -> false
  end 
    
end

defp valid_public_key?(<<4, second, _rest::binary-size(32)>>) when second in [2, 3], do: true
defp valid_public_key?(_), do: false

Post #3

— All posts loaded —