feat: Add SecureRAndom.base58/1

Based originally on patricksrobertson#12, but modified to
prevent namespace pollution of the Base58 translation module.

Author: halostatue

lib/secure_random.ex

@@ -103,6 +103,25 @@ defmodule SecureRandom do
     :crypto.strong_rand_bytes(n)
   end
 
+  @doc """
+  Returns random Base58 encoded string.
+
+  ## Examples
+
+      iex> SecureRandom.base58
+      "Y5oZt858wSQbnGrxAZTyrY"
+
+      iex> SecureRandom.base58(8)
+      "4xxSsC4PKq5"
+
+  """
+  def base58(n \\ @default_length) do
+    n
+    |> random_bytes()
+    |> :binary.bin_to_list()
+    |> charlist_to_base58()
+  end
+
   defp bigenerate do
     <<u0::48, _::4, u1::12, _::2, u2::62>> = random_bytes(16)
     <<u0::48, 4::4, u1::12, 2::2, u2::62>>
@@ -128,4 +147,17 @@ defmodule SecureRandom do
   defp lower(<<h, t::binary>>, acc) when h in ?A..?F, do: lower(t, acc <> <<h + 32>>)
   defp lower(<<h, t::binary>>, acc), do: lower(t, acc <> <<h>>)
   defp lower(<<>>, acc), do: acc
+
+  defp int_to_base58(x) when x >= 58,
+    do: SecureRandom.Base58.b58char(:rand.uniform(57))
+
+  defp int_to_base58(x),
+    do: SecureRandom.Base58.b58char(x)
+
+  defp charlist_to_base58(chars) do
+    chars
+    |> Enum.map(&rem(&1, 64))
+    |> Enum.map(&int_to_base58(&1))
+    |> List.to_string()
+  end
 end

lib/secure_random/base58.ex

@@ -0,0 +1,62 @@
+defmodule SecureRandom.Base58 do
+  @moduledoc false
+
+  def b58char(0), do: ?1
+  def b58char(1), do: ?2
+  def b58char(2), do: ?3
+  def b58char(3), do: ?4
+  def b58char(4), do: ?5
+  def b58char(5), do: ?6
+  def b58char(6), do: ?7
+  def b58char(7), do: ?8
+  def b58char(8), do: ?9
+  def b58char(9), do: ?A
+  def b58char(10), do: ?B
+  def b58char(11), do: ?C
+  def b58char(12), do: ?D
+  def b58char(13), do: ?E
+  def b58char(14), do: ?F
+  def b58char(15), do: ?G
+  def b58char(16), do: ?H
+  def b58char(17), do: ?J
+  def b58char(18), do: ?K
+  def b58char(19), do: ?L
+  def b58char(20), do: ?M
+  def b58char(21), do: ?N
+  def b58char(22), do: ?P
+  def b58char(23), do: ?Q
+  def b58char(24), do: ?R
+  def b58char(25), do: ?S
+  def b58char(26), do: ?T
+  def b58char(27), do: ?U
+  def b58char(28), do: ?V
+  def b58char(29), do: ?W
+  def b58char(30), do: ?X
+  def b58char(31), do: ?Y
+  def b58char(32), do: ?Z
+  def b58char(33), do: ?a
+  def b58char(34), do: ?b
+  def b58char(35), do: ?c
+  def b58char(36), do: ?d
+  def b58char(37), do: ?e
+  def b58char(38), do: ?f
+  def b58char(39), do: ?g
+  def b58char(40), do: ?h
+  def b58char(41), do: ?i
+  def b58char(42), do: ?j
+  def b58char(43), do: ?k
+  def b58char(44), do: ?m
+  def b58char(45), do: ?n
+  def b58char(46), do: ?o
+  def b58char(47), do: ?p
+  def b58char(48), do: ?q
+  def b58char(49), do: ?r
+  def b58char(50), do: ?s
+  def b58char(51), do: ?t
+  def b58char(52), do: ?u
+  def b58char(53), do: ?v
+  def b58char(54), do: ?w
+  def b58char(55), do: ?x
+  def b58char(56), do: ?y
+  def b58char(57), do: ?z
+end

test/secure_random_test.exs

@@ -43,4 +43,16 @@ defmodule SecureRandomTest do
     # that standard is 128 bit string 4byte-2byte-2byte-2byte-6byte
     assert Regex.match?(~r/\A\w{8}-\w{4}-4\w{3}-(8|9|a|b)\w{3}-\w{12}\z/, SecureRandom.uuid())
   end
+
+  test "base58/1 returns a Binary string" do
+    assert is_binary(SecureRandom.base58())
+  end
+
+  test "base58/1 defaults to a byte size of 16" do
+    assert 16 == byte_size(SecureRandom.base58())
+  end
+
+  test "base58/1 successfully takes a byte_length" do
+    assert 24 == byte_size(SecureRandom.base58(24))
+  end
 end