View Source Tezex.Forge (tezex v3.0.1)

Decode a contract (address + optional entrypoint) from bytes, returning a string with the base58 encoded address and, if present, the entrypoint separated by %.

unforge_int(data, input_encoding \\ :bytes)

Decode a signed unbounded integer from bytes.

unforge_micheline(data, input_encoding \\ :bytes)

Parse Micheline map from bytes.

unforge_public_key(data, input_encoding \\ :bytes)

unforge_signature(data, input_encoding \\ :bytes)

Types

base58_encoding()

@type base58_encoding() :: %{
  e_prefix: String.t(),
  e_len: non_neg_integer(),
  d_prefix: binary(),
  d_len: non_neg_integer()
}

Represents a base58 encoding configuration.

io_encoding()

@type io_encoding() :: :bytes | :hex

Represents the encoding type for input/output operations. Can be either :bytes for raw binary data or :hex for hexadecimal string representation.

Functions

forge_address(value, output_encoding \\ :bytes, tz_only \\ false)

@spec forge_address(binary(), io_encoding(), boolean()) :: nonempty_binary()

Encode address or key hash into bytes.

value is a base58 encoded address or key_hash
tz_only indicates that it's a key_hash (will be encoded in a more compact form)

forge_array(data, output_encoding \\ :bytes, len_bytes \\ 4)

@spec forge_array(binary(), io_encoding(), non_neg_integer()) :: binary()

forge_base58(value, output_encoding \\ :bytes)

@spec forge_base58(binary(), io_encoding()) :: binary()

forge_bool(value, output_encoding \\ :bytes)

@spec forge_bool(boolean(), io_encoding()) :: nonempty_binary()

forge_contract(value, output_encoding \\ :bytes)

@spec forge_contract(binary(), io_encoding()) :: binary()

forge_int16(value, output_encoding \\ :bytes)

@spec forge_int16(integer(), io_encoding()) :: nonempty_binary()

forge_int32(value, output_encoding \\ :bytes)

@spec forge_int32(integer(), io_encoding()) :: nonempty_binary()

forge_int(value, output_encoding \\ :bytes)

@spec forge_int(integer(), io_encoding()) :: nonempty_binary()

Encodes a signed unbounded integer into byte form.

Parameters

value - The integer to be encoded.
output_encoding - The encoding type for the output. Defaults to :bytes.

Returns

A binary string representing the encoded integer.

Examples

iex> forge_int(123)
<<123>>

iex> forge_int(123, :hex)
"7B"

forge_micheline(data, output_encoding \\ :bytes)

@spec forge_micheline(list() | map(), io_encoding()) :: binary()

Encode a Micheline expression into byte form.

forge_nat(value, output_encoding \\ :bytes)

@spec forge_nat(non_neg_integer(), io_encoding()) :: nonempty_binary()

Encode a non-negative integer using LEB128 encoding.

forge_public_key(value, output_encoding \\ :bytes)

@spec forge_public_key(binary(), io_encoding()) :: nonempty_binary()

forge_script(script, output_encoding \\ :bytes)

@spec forge_script(map(), io_encoding()) :: binary()

forge_script_expr(packed_key, output_encoding \\ :bytes)

@spec forge_script_expr(binary(), io_encoding()) :: nonempty_binary()

optimize_timestamp(value)

@spec optimize_timestamp(binary()) :: integer()

unforge_address(data, input_encoding \\ :bytes)

@spec unforge_address(binary(), io_encoding()) :: nonempty_binary()

unforge_array(data, input_encoding \\ :bytes, len_bytes \\ 4)

@spec unforge_array(binary(), io_encoding(), non_neg_integer()) ::
  {binary(), non_neg_integer()}

unforge_chain_id(data, input_encoding \\ :bytes)

@spec unforge_chain_id(binary(), io_encoding()) :: nonempty_binary()

unforge_contract(data, input_encoding \\ :bytes)

@spec unforge_contract(binary(), io_encoding()) :: nonempty_binary()