defmodule Bitcoinex.Script do
  @moduledoc """
  	a module for manipulating Bitcoin Scripts
  """

  import Bitcoinex.Opcode

  alias Bitcoinex.Secp256k1.Point

  alias Bitcoinex.{Utils, Address, Segwit, Base58, Network}

  @wsh_length 32
  @tapkey_length 32
  @h160_length 20
  @pubkey_lengths [33, 65]

  @type script_type :: :p2pk | :p2pkh | :p2sh | :p2wpkh | :p2wsh | :p2tr | :multi | :non_standard

  @type t :: %__MODULE__{
          items: list
        }

  @enforce_keys [
    :items
  ]
  defstruct [:items]

  defguard is_valid_multi(m, pubkeys)
           when is_integer(m) and m > 0 and length(pubkeys) > 0 and length(pubkeys) >= m

  defp invalid_opcode_error(msg), do: {:error, "invalid opcode: #{msg}"}

  def is_valid_opcode(i) when is_integer(i), do: i >= 0x00 && i < 0xFF

  @doc """
  	new returns an empty script object.
  """
  @spec new() :: t()
  def new, do: %__MODULE__{items: []}

  @doc """
  	to_list returns the script as a list of items
  """
  @spec to_list(t()) :: list
  def to_list(%__MODULE__{items: script}), do: script

  @doc """
  	empty? returns true for empty scripts, false otherwise.
  """
  @spec empty?(t()) :: bool
  def empty?(%__MODULE__{items: []}), do: true
  def empty?(_), do: false

  @doc """
  	script_length returns the number of items in the script.
  """
  @spec script_length(t()) :: non_neg_integer()
  def script_length(%__MODULE__{items: items}), do: length(items)

  @doc """
  	byte_length returns the byte length of the serialized script.
  """
  @spec byte_length(t()) :: non_neg_integer()
  def byte_length(script) do
    script
    |> serialize_script()
    |> byte_size()
  end

  @doc """
    hash160 is a helper function which returns the hash160
    digest of the serialized script, as used in P2SH scripts.
  """
  @spec hash160(t()) :: binary
  def hash160(script = %__MODULE__{}) do
    script
    |> serialize_script()
    |> Utils.hash160()
  end

  @doc """
    hash256 is a helper function which returns the hash256
    digest of the serialized script, as used in P2WSH scripts.
  """
  @spec sha256(t()) :: binary
  def sha256(script = %__MODULE__{}) do
    script
    |> serialize_script()
    |> Utils.sha256()
  end

  @doc """
  	get_op_num returns the integer associated with the passed opcode atom.
  """
  @spec get_op_num(atom) :: {:ok, non_neg_integer()} | :error
  def get_op_num(op), do: Map.fetch(opcode_atoms(), op)

  @doc """
  	get_op_atom returns the atom associated with the passed opcode integer.
  """
  @spec get_op_atom(non_neg_integer()) :: non_neg_integer() | {:ok, atom}
  def get_op_atom(i), do: if(i > 0 and i < 0x4C, do: i, else: Map.fetch(opcode_nums(), i))

  @doc """
  	pop returns the first element of the script and the remaining script.
  	Returns nil if script is empty
  """
  @spec pop(t()) :: nil | {:ok, non_neg_integer() | binary, t()}
  def pop(%__MODULE__{items: []}), do: nil
  def pop(%__MODULE__{items: [item | stack]}), do: {:ok, item, %__MODULE__{items: stack}}

  @doc """
  	push_op pushes a single opcode to the script as an integer and returns the script.
  """
  @spec push_op(t(), atom | non_neg_integer()) :: {:ok, t()} | {:error, String.t()}
  def push_op(%__MODULE__{items: stack}, item) do
    # item is opcode num
    if is_integer(item) and item >= 0 and item < 0xFF do
      {:ok, %__MODULE__{items: [item | stack]}}
    else
      # item is atom
      case get_op_num(item) do
        :error -> invalid_opcode_error(item)
        {:ok, op} -> {:ok, %__MODULE__{items: [op | stack]}}
      end
    end
  end

  # used to push data lengths and raw binary
  defp push_raw_data(%__MODULE__{items: stack}, data) do
    %__MODULE__{items: [data | stack]}
  end

  @doc """
  	push_data returns a script with the binary data and any
  	accompanying pushdata or pushbytes opcodes added to the front of the script.
  """
  @spec push_data(t(), binary) :: {:ok, t()} | {:error, String.t()}
  def push_data(script = %__MODULE__{}, data) do
    datalen = byte_size(data)
    script = push_raw_data(script, data)

    cond do
      datalen < 0x4C ->
        push_op(script, datalen)

      datalen <= 0xFF ->
        push_op(script, :op_pushdata1)

      datalen <= 0xFFFF ->
        push_op(script, :op_pushdata2)

      datalen <= 0xFFFFFFFF ->
        push_op(script, :op_pushdata4)

      true ->
        {:error, "invalid data length, must be 0..0xffffffff, got #{datalen}"}
    end
  end

  # SERIALIZE & PARSE
  defp serializer(%__MODULE__{items: []}, acc), do: acc

  defp serializer(%__MODULE__{items: [item | script]}, acc) when is_integer(item) do
    # prevents UTF-8 ints from becoming strings
    serializer(%__MODULE__{items: script}, acc <> Utils.int_to_little(item, 1))
  end

  # For data pushes
  defp serializer(%__MODULE__{items: [item | script]}, acc) when is_binary(item) do
    len = byte_size(item)

    cond do
      # CHECK IF PUSHBYTES75 is valid
      len < 0x4C ->
        serializer(%__MODULE__{items: script}, acc <> item)

      len <= 0xFF ->
        len = len |> Utils.int_to_little(1)
        serializer(%__MODULE__{items: script}, acc <> len <> item)

      # PUSHDATA limited to 520 bytes, so no PUSHDATA2 > 520 is a valid script.
      # Should we allow this?
      len <= 0xFFFF ->
        len = Utils.int_to_little(len, 2)
        serializer(%__MODULE__{items: script}, acc <> len <> item)

      # no PUSHDATA4 is a valid script.
      # Should we allow this?
      len <= 0xFFFFFFFF ->
        len = Utils.int_to_little(len, 4)
        serializer(%__MODULE__{items: script}, acc <> len <> item)
    end
  end

  @doc """
  	serialize_script serializes the script into binary
  	according to Bitcoin's standard.
  """
  @spec serialize_script(t()) :: binary
  def serialize_script(script = %__MODULE__{}) do
    # serialize_script(%Script{items: [0x51]}) will still display "Q" but
    # it functions as binary 0x51. Use to_hex for displaying scripts.
    serializer(script, <<>>)
  end

  @doc """
  	to_hex returns the hex of a serialized script.
  """
  @spec to_hex(t()) :: String.t()
  def to_hex(script) do
    script
    |> serialize_script()
    |> Base.encode16(case: :lower)
  end

  @doc """
  	parse_script parses a binary or hex string into a script.
  """
  @spec parse_script(binary) :: {:ok, t()} | {:error, String.t()}
  def parse_script(script_str) when is_binary(script_str) do
    try do
      case Utils.hex_to_bin(script_str) do
        {:error, _msg} ->
          # necessary to allow parse_script to accept raw binary script
          parser(new(), script_str)

        bin ->
          parser(new(), bin)
      end
    rescue
      _ -> {:error, "invalid script. parse_script accepts hex or binary."}
    end
  end

  defp parser(script, <<>>), do: {:ok, script}

  defp parser(script, <<next::binary-size(1), bin::binary>>) do
    op = :binary.decode_unsigned(next)

    cond do
      # PUSHBYTES
      op > 0x00 and op < 0x4C ->
        {:ok, rest} = parser(script, :binary.part(bin, op, byte_size(bin) - op))

        rest
        |> push_raw_data(:binary.part(bin, 0, op))
        |> push_op(op)

      # PUSHDATA1
      op == 0x4C ->
        len = bin |> :binary.part(0, 1) |> Utils.little_to_int()
        {:ok, rest} = parser(script, :binary.part(bin, len + 1, byte_size(bin) - len - 1))

        rest
        |> push_raw_data(:binary.part(bin, 1, len))
        |> push_op(op)

      # PUSHDATA2
      op == 0x4D ->
        len = bin |> :binary.part(0, 2) |> Utils.little_to_int()
        {:ok, rest} = parser(script, :binary.part(bin, len + 2, byte_size(bin) - len - 2))

        rest
        |> push_raw_data(:binary.part(bin, 2, len))
        |> push_op(op)

      # PUSHDATA4
      op == 0x4E ->
        len = bin |> :binary.part(0, 4) |> Utils.little_to_int()
        {:ok, rest} = parser(script, :binary.part(bin, len + 4, byte_size(bin) - len - 4))

        rest
        |> push_raw_data(:binary.part(bin, 4, len))
        |> push_op(op)

      # OPCODE
      is_valid_opcode(op) ->
        {:ok, rest} = parser(script, :binary.part(bin, 0, byte_size(bin)))
        push_op(rest, op)

      true ->
        invalid_opcode_error(op)
    end
  end

  @doc """
  	raw_combine directly concatenates two scripts with no checks.
  """
  @spec raw_combine(t(), t()) :: t()
  def raw_combine(%__MODULE__{items: s1}, %__MODULE__{items: s2}),
    do: %__MODULE__{items: s1 ++ s2}

  @doc """
  	display_script returns a human readable string of the script, with
  	op_codes shown by name rather than number.
  """
  @spec display_script(t()) :: String.t()
  def display_script(script) do
    " " <> scriptxt = display_script(script, "")
    scriptxt
  end

  defp display_script(%__MODULE__{items: []}, acc), do: acc

  defp display_script(%__MODULE__{items: [item | stack]}, acc) when is_integer(item) do
    if item > 0 and item < 0x4C do
      display_script(%__MODULE__{items: stack}, acc <> " OP_PUSHBYTES_#{item}")
    else
      {:ok, op_atom} = get_op_atom(item)
      upper_op = op_atom |> to_string() |> String.upcase()
      display_script(%__MODULE__{items: stack}, acc <> " " <> upper_op)
    end
  end

  defp display_script(%__MODULE__{items: [item | stack]}, acc) when is_binary(item) do
    display_script(%__MODULE__{items: stack}, acc <> " " <> Base.encode16(item, case: :lower))
  end

  # SCRIPT TYPE DETERMINERS

  @doc """
  	is_p2pk? returns whether a given script is of the p2pk format:
  	<33-byte or 65-byte pubkey> OP_CHECKSIG
  """
  @spec is_p2pk?(t()) :: boolean
  def is_p2pk?(%__MODULE__{
        items: [len, pubkey, 0xAC]
      })
      when len in @pubkey_lengths and len == byte_size(pubkey) do
    true
  end

  def is_p2pk?(%__MODULE__{}), do: false

  @doc """
  	is_p2pkh? returns whether a given script is of the p2pkh format:
  	OP_DUP OP_HASH160 OP_PUSHBYTES_20 <20-byte hash> OP_EQUALVERIFY OP_CHECKSIG
  """
  @spec is_p2pkh?(t()) :: boolean
  def is_p2pkh?(%__MODULE__{
        items: [0x76, 0xA9, @h160_length, <<_::binary-size(@h160_length)>>, 0x88, 0xAC]
      }),
      do: true

  def is_p2pkh?(%__MODULE__{}), do: false

  @doc """
  	is_p2sh? returns whether a given script is of the p2sh format:
  	OP_HASH160 OP_PUSHBYTES_20 <20-byte hash> OP_EQUAL
  """
  @spec is_p2sh?(t()) :: boolean
  def is_p2sh?(%__MODULE__{items: [0xA9, @h160_length, <<_::binary-size(@h160_length)>>, 0x87]}),
    do: true

  def is_p2sh?(%__MODULE__{}), do: false

  @doc """
  	is_p2wpkh? returns whether a given script is of the p2wpkh format:
  	OP_0 OP_PUSHBYTES_20 <20-byte hash>
  """
  @spec is_p2wpkh?(t()) :: boolean
  def is_p2wpkh?(%__MODULE__{items: [0x00, @h160_length, <<_::binary-size(@h160_length)>>]}),
    do: true

  def is_p2wpkh?(%__MODULE__{}), do: false

  @doc """
  	is_p2wsh? returns whether a given script is of the p2wsh format:
  	OP_0 OP_PUSHBYTES_32 <32-byte hash>
  """
  @spec is_p2wsh?(t()) :: boolean
  def is_p2wsh?(%__MODULE__{items: [0x00, @wsh_length, <<_::binary-size(@wsh_length)>>]}),
    do: true

  def is_p2wsh?(%__MODULE__{}), do: false

  @doc """
  	is_p2tr? returns whether a given script is of the p2tr format:
  	OP_1 OP_PUSHBYTES_32 <32-byte hash>
  """
  @spec is_p2tr?(t()) :: boolean
  def is_p2tr?(%__MODULE__{items: [0x51, @tapkey_length, <<_::binary-size(@tapkey_length)>>]}),
    do: true

  def is_p2tr?(%__MODULE__{}), do: false

  @doc """
  	is_multi? returns whether a given script is of the raw multisig format:
  	OP_(INT) [Public Keys] OP_(INT) OP_CHECKMULTISIG
  """
  @spec is_multi?(t()) :: boolean
  def is_multi?(%__MODULE__{items: [op_m | rest]})
      when op_m > 0x50 and op_m <= 0x60 and length(rest) > 3 do
    test_multi(rest, 0, op_m)
  end

  def is_multi?(_), do: false

  defp test_multi([op_n, 0xAE], n, m) when op_n == 0x50 + n and m <= op_n, do: true

  defp test_multi([op_push | [pk | rest]], n, m) when op_push in @pubkey_lengths do
    case Point.parse_public_key(pk) do
      {:ok, _pk} -> test_multi(rest, n + 1, m)
      {:error, _msg} -> false
    end
  end

  defp test_multi(_, _, _), do: false

  @doc """
    extract_multi_policy takes in a raw multisig script and returns the m, the
    number of signatures required and the n authorized public keys.
  """
  @spec extract_multi_policy(t()) ::
          {:ok, non_neg_integer(), list(Point.t())} | {:error, String.t()}
  def extract_multi_policy(script = %__MODULE__{items: [op_m | items]}) do
    if is_multi?(script) do
      {:ok, op_m - 0x50, extractor(items, [])}
    else
      {:error, "invalid raw multisig script"}
    end
  end

  defp extractor([_op_n, 0xAE], keys), do: keys

  defp extractor([_op_push | [key | items]], keys) do
    case Point.parse_public_key(key) do
      {:ok, pk} -> [pk | extractor(items, keys)]
      {:error, msg} -> {:error, "invalid public key: #{msg}"}
    end
  end

  @doc """
  	get_script_type determines the type of a script based on its elements
  	returns :non_standard if no type matches
  """
  @spec get_script_type(t()) :: script_type
  def get_script_type(script = %__MODULE__{}) do
    cond do
      # sorted by most prevalent
      is_p2pkh?(script) -> :p2pkh
      is_p2sh?(script) -> :p2sh
      is_p2wpkh?(script) -> :p2wpkh
      is_p2wsh?(script) -> :p2wsh
      is_p2pk?(script) -> :p2pk
      is_p2tr?(script) -> :p2tr
      is_multi?(script) -> :multi
      true -> :non_standard
    end
  end

  # CREATE COMMON SCRIPTS

  @doc """
  	create_p2pk creates a p2pk script using the passed public key
  """
  @spec create_p2pk(binary) :: {:ok, t()} | {:error, String.t()}
  def create_p2pk(pk) when is_binary(pk) and byte_size(pk) in [33, 65] do
    {:ok, s} = push_op(new(), 0xAC)
    push_data(s, pk)
  end

  def create_p2pk(_), do: {:error, "pubkey must be 33 or 65 bytes compressed or uncompressed SEC"}

  @doc """
  	create_p2pkh creates a p2pkh script using the passed 20-byte public key hash
  """
  @spec create_p2pkh(binary) :: {:ok, t()} | {:error, String.t()}
  def create_p2pkh(<<pkh::binary-size(@h160_length)>>) do
    {:ok, s} = push_op(new(), 0xAC)
    {:ok, s} = push_op(s, 0x88)
    {:ok, s} = push_data(s, pkh)
    {:ok, s} = push_op(s, 0xA9)
    push_op(s, 0x76)
  end

  def create_p2pkh(_), do: {:error, "pubkey hash must be a #{@h160_length}-byte hash"}

  @doc """
  	create_p2sh creates a p2sh script using the passed 20-byte public key hash
  """
  @spec create_p2sh(binary) :: {:ok, t()} | {:error, String.t()}
  def create_p2sh(<<sh::binary-size(@h160_length)>>) do
    {:ok, s} = push_op(new(), 0x87)
    {:ok, s} = push_data(s, sh)
    push_op(s, 0xA9)
  end

  def create_p2sh(_), do: {:error, "script hash must be a #{@h160_length}-byte hash"}

  @doc """
    to_p2sh wraps any script in a p2sh by first hashing it (hash160)
    and then wrapping then script hash in a p2sh script.
  """
  @spec to_p2sh(t()) :: {:ok, t()} | {:error, String.t()}
  def to_p2sh(script = %__MODULE__{}) do
    script
    |> hash160()
    |> create_p2sh()
  end

  @doc """
    create_multi creates a raw multisig script using m and the list of public keys.
  """
  @spec create_multi(non_neg_integer(), list(Point.t())) :: {:ok, t()} | {:error, String.t()}
  def create_multi(m, pubkeys) when is_valid_multi(m, pubkeys) do
    try do
      # checkmultisig
      {:ok, s} = push_op(new(), 0xAE)
      {:ok, s} = push_op(s, 0x50 + length(pubkeys))
      s = fill_multi_keys(s, pubkeys)
      push_op(s, 0x50 + m)
    rescue
      _ -> {:error, "invalid public key."}
    end
  end

  def create_multi(_, _), do: {:error, "invalid multisig: must be of form: (int, list(%Point)"}

  defp fill_multi_keys(s, []), do: s

  defp fill_multi_keys(s, [pk = %Point{} | pubkeys]) do
    {:ok, s} = push_data(fill_multi_keys(s, pubkeys), Point.sec(pk))
    s
  end

  defp fill_multi_keys(_, _), do: raise(ArgumentError)

  @doc """
    create_p2sh_multi returns both a P2SH-wrapped multisig script
    and the underlying raw multisig script using m and the list of public keys.
  """
  @spec create_p2sh_multi(non_neg_integer(), list(Point.t())) ::
          {:ok, t(), t()} | {:error, String.t()}
  def create_p2sh_multi(m, pubkeys) do
    case create_multi(m, pubkeys) do
      {:ok, multi} ->
        h160 = hash160(multi)
        {:ok, p2sh} = create_p2sh(h160)
        {:ok, p2sh, multi}

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

  @doc """
    create_p2wsh_multi returns both a P2WSH-wrapped multisig script
    and the underlying raw multisig script using m and the list of public keys.
  """
  @spec create_p2wsh_multi(non_neg_integer(), list(Point.t())) ::
          {:ok, t(), t()} | {:error, String.t()}
  def create_p2wsh_multi(m, pubkeys) do
    case create_multi(m, pubkeys) do
      {:ok, multi} ->
        h256 = sha256(multi)
        {:ok, p2wsh} = create_p2wsh(h256)
        {:ok, p2wsh, multi}

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

  @doc """
  	create_witness_scriptpubkey creates any witness script from a witness version
  	and witness program. It performs no validity checks.
  """
  @spec create_witness_scriptpubkey(non_neg_integer(), binary) :: {:ok, t()}
  def create_witness_scriptpubkey(version, witness_program) do
    wit_version_adjusted = if(version == 0, do: 0, else: version + 0x50)
    {:ok, s} = push_data(new(), witness_program)
    push_op(s, wit_version_adjusted)
  end

  @doc """
  	create_p2wpkh creates a p2wpkh script using the passed 20-byte public key hash
  """
  @spec create_p2wpkh(binary) :: {:ok, t()}
  def create_p2wpkh(<<pkh::binary-size(@h160_length)>>),
    do: create_witness_scriptpubkey(0, pkh)

  def create_p2wpkh(_), do: {:error, "pubkey hash must be a #{@h160_length}-byte hash"}

  @doc """
  	create_p2wsh creates a p2wsh script using the passed 32-byte script hash
  """
  @spec create_p2wsh(binary) :: {:ok, t()}
  def create_p2wsh(<<sh::binary-size(@wsh_length)>>), do: create_witness_scriptpubkey(0, sh)
  def create_p2wsh(_), do: {:error, "script hash must be a #{@wsh_length}-byte hash"}

  @doc """
    to_p2wsh converts any script into a p2wsh script by hashing it (SHA256)
    then wrapping the script hash as a p2wsh script.
  """
  @spec to_p2wsh(t()) :: {:ok, t()}
  def to_p2wsh(script = %__MODULE__{}) do
    script
    |> sha256()
    |> create_p2wsh()
  end

  @doc """
  	create_p2tr creates a p2tr script using the passed 32-byte public key
    or Point. If a point is passed, it's interpreted as q, the full witness
    program or taproot output key per BIP 341 rather than the keyspend pubkey.
  """
  @spec create_p2tr(binary | Point.t()) :: {:ok, t()}
  def create_p2tr(<<pk::binary-size(@tapkey_length)>>), do: create_witness_scriptpubkey(1, pk)
  def create_p2tr(q = %Point{}), do: create_witness_scriptpubkey(1, Point.x_bytes(q))
  def create_p2tr(_), do: {:error, "public key must be #{@tapkey_length}-bytes"}

  @doc """
  	create_p2sh_p2wpkh creates a p2wsh script using the passed 20-byte public key hash
  """
  @spec create_p2sh_p2wpkh(binary) :: {:ok, t(), t()}
  def create_p2sh_p2wpkh(<<pkh::binary-size(@h160_length)>>) do
    {:ok, p2wpkh} = create_p2wpkh(pkh)

    {:ok, p2sh} =
      p2wpkh
      |> serialize_script()
      |> Utils.hash160()
      |> create_p2sh()

    # return both p2sh script and redeem script (p2wpkh script)
    {:ok, p2sh, p2wpkh}
  end

  def create_p2sh_p2wpkh(_), do: {:error, "public key hash must be #{@h160_length}-bytes"}

  # CREATE SCRIPTS FROM PUBKEYS

  @doc """
  	public_key_hash takes the hash160 of the public key's compressed sec encoding.
  	Can be used to create a pkh script.
  """
  @spec public_key_hash(Point.t()) :: binary
  def public_key_hash(p = %Point{}) do
    p
    |> Point.sec()
    |> Utils.hash160()
  end

  @doc """
  	public_key_to_p2pkh creates a p2pkh script from a public key.
  	All public keys are compressed.
  """
  @spec public_key_to_p2pkh(Point.t()) :: {:ok, t()}
  def public_key_to_p2pkh(p = %Point{}) do
    p
    |> public_key_hash()
    |> create_p2pkh()
  end

  def public_key_to_p2pkh(_), do: {:error, "invalid public key"}

  @doc """
  	public_key_to_p2wpkh creates a p2wpkh script from a public key.
  	All public keys are compressed.
  """
  @spec public_key_to_p2wpkh(Point.t()) :: {:ok, t()}
  def public_key_to_p2wpkh(p = %Point{}) do
    p
    |> public_key_hash()
    |> create_p2wpkh()
  end

  def public_key_to_p2wpkh(_), do: {:error, "invalid public key"}

  @doc """
  	public_key_to_p2sh_p2wpkh creates a p2sh-p2wpkh script from a public key.
  	All public keys are compressed.
  """
  @spec public_key_to_p2sh_p2wpkh(Point.t()) :: {:ok, t(), t()}
  def public_key_to_p2sh_p2wpkh(p = %Point{}) do
    p
    |> public_key_hash()
    |> create_p2sh_p2wpkh()
  end

  def public_key_to_p2sh_p2wpkh(_), do: {:error, "invalid public key"}

  # ADDRESS CREATION & DECODING

  @doc """
  	from_address produces the scriptpubkey from an address.
  """
  @spec from_address(String.t()) ::
          {:error, String.t()} | {:ok, t(), Bitcoinex.Network.network_name()}
  def from_address(addr) do
    case String.slice(addr, 0, 2) do
      # segwit addresses
      p when p in ["bc", "tb"] ->
        case Segwit.decode_address(addr) do
          {:ok, {network, version, program}} ->
            {:ok, script} = create_witness_scriptpubkey(version, :binary.list_to_bin(program))
            {:ok, script, network}

          {:error, msg} ->
            {:error, "invalid segwit address: #{msg}"}
        end

      # legacy addresses
      _ ->
        try do
          {:ok, <<pfx::little-size(8), body::binary>>} = Base58.decode(addr)
          tpkh = Network.testnet().p2pkh_version_decimal_prefix
          mpkh = Network.mainnet().p2pkh_version_decimal_prefix
          tsh = Network.testnet().p2sh_version_decimal_prefix
          msh = Network.mainnet().p2sh_version_decimal_prefix

          case pfx do
            # p2pkh testnet
            ^tpkh ->
              {:ok, s} = create_p2pkh(body)
              {:ok, s, :testnet}

            # p2pkh mainnet
            ^mpkh ->
              {:ok, s} = create_p2pkh(body)
              {:ok, s, :mainnet}

            # p2sh testnet
            ^tsh ->
              {:ok, s} = create_p2sh(body)
              {:ok, s, :testnet}

            # p2sh mainnet
            ^msh ->
              {:ok, s} = create_p2sh(body)
              {:ok, s, :mainnet}
          end
        rescue
          _ -> {:error, "invalid address"}
        end
    end
  end

  @doc """
  	to_address converts a script object into the proper address type
  """
  @spec to_address(t(), Network.network_name()) ::
          {:ok, String.t()} | {:error, String.t()}
  def to_address(script = %__MODULE__{}, network) do
    {:ok, head, script} = pop(script)

    case head do
      # segwit 0
      0x00 ->
        {:ok, len, script} = pop(script)
        {:ok, <<res::binary-size(len)>>, _script} = pop(script)

        if len in [@h160_length, @wsh_length] do
          Segwit.encode_address(network, 0, :binary.bin_to_list(res))
        else
          {:error, "invalid witness program length. Must be in [#{@h160_length}, #{@wsh_length}]"}
        end

      # segwit 1 (taproot)
      0x51 ->
        {:ok, @tapkey_length, script} = pop(script)
        {:ok, <<res::binary-size(@tapkey_length)>>, _script} = pop(script)
        Segwit.encode_address(network, 1, :binary.bin_to_list(res))

      # p2sh
      0xA9 ->
        {:ok, @h160_length, script} = pop(script)
        {:ok, <<res::binary-size(@h160_length)>>, _script} = pop(script)
        {:ok, Address.encode(res, network, :p2sh)}

      # p2pkh
      0x76 ->
        {:ok, 0xA9, script} = pop(script)
        {:ok, @h160_length, script} = pop(script)
        {:ok, <<res::binary-size(@h160_length)>>, _script} = pop(script)
        {:ok, Address.encode(res, network, :p2pkh)}

      _ ->
        {:error, "non standard script type"}
    end
  end
end

defimpl String.Chars, for: Bitcoinex.Script do
  def to_string(script) do
    Bitcoinex.Script.display_script(script)
  end
end