Adds two integers (+).

Subtract two integers (-).

Multiple two integers (*).

Integer division truncated towards negative infinity (/).

Integer division truncated towards zero.

Integer remainder, satisfying

quotient_integer(x, y) * y + remainder_integer(x, y) == x

Integer modulus (%), satisfying

divide_integer(x, y) * y + mod_integer(x, y) == x

Integer equality.

Integer strict inequality.

Integer inequality.

Convert an integer value into a ByteArray.

• The first arguments / specifies the endianness:

  boolean value	endianness
  True	Big endian
  False	Little endian

• The second argument indicates the target size (in bytes) of the final ByteArray. This allows to allocate a specific number of bytes in advance. The function fails if the given value cannot fit in the requested size or if the value is negative. However, a size of 0 will yield a ByteArray that is precisely as large as necessary to fit the value.

Concatenate two bytearrays together.

Push a byte in front of a bytearray.

Construct a ByteArray from the repetition of the same byte a specific number of times. Fails if the byte is out-of-bound or if the length is negative.

Count the number of bits set in the given ByteArray.

Find the index of the first bit set. Note that bits are indexed from the end (see also read_bit for more details).

Access the byte at the given index in the bytearray.

Number of bytes in a bytearray.

Read a particular bit (True if set) at the given index. Fails if the index is out-of-bounds. Note that the index reads from the end. For example, consider the byte 0xF4 and an index i:

So, we have:

read_bit(#[0xF4], 0) == False
read_bit(#[0xF4], 1) == False
read_bit(#[0xF4], 2) == True
read_bit(#[0xF4], 3) == False
read_bit(#[0xF4], 4) == True
read_bit(#[0xF4], 5) == True
read_bit(#[0xF4], 6) == True
read_bit(#[0xF4], 7) == True
read_bit(#[0xF4, 0xF4], 8) == False

Extract a sub-array from a bytearray given starting and length of the sub-array.

Write a bit each index in the list of indices. Writes 1 if value is True and 0 if value is False. Fails if the index is out-of-bounds. Note that the index reads from the end. For example, consider the byte 0xF4 and an index i:

So, we have:

write_bits(#[0xF4], [0, 1], True) == #[0xF7]

Bytearray equality.

Bytearray strict inequality.

Bytearray inequality.

Logical AND applied to two bytearrays. The first argument indicates whether padding semantics should be used. If this argument is False, truncation semantics are used instead.

Logical OR applied to two bytearrays. The first argument indicates whether padding semantics should be used. If this argument is False, truncation semantics are used instead.

Logical XOR applied to two bytearrays. The first argument indicates whether padding semantics should be used. If this argument is False, truncation semantics are used instead.

Logical bitwise complement of the bytearray (set becomes unset, and unset becomes set).

Like shift_bytearray but instead of introducing zeroes in holes, use the bits that are dropped from either ends.

rotate_bytearray(#[0xEB, 0xFC], 5) == #[0x7F, 0x9D]
rotate_bytearray(#[0xEB, 0xFC], -8) == #[0xFC, 0xEB]
rotate_bytearray(#[0xEB, 0xFC], 8) == #[0xFC, 0xEB]

Shift bits in a ByteArray by the given offset, replacing holes with zeroes. The offset can be positive (left-shift) or negative (right-shift).

shift_bytearray(#[0xEB, 0xFC], 5) == #[0x7F, 0x80]
shift_bytearray(#[0xEB, 0xFC], -8) == #[0x00, 0xEB]
shift_bytearray(#[0xEB, 0xFC], 8) == #[0xFC, 0x00]

Convert a ByteArray to an integer value. The first argument specifies the endianness:

Concatenate two strings.

String equality.

Convert a string into a UTF-8 encoded array of bytes.

Interpret a UTF-8 encoded array of bytes as a String. Fails if the bytes aren’t UTF-8 encoded.

Construct an empty list of Data.

Push an element in front of a list.

The head of a list. Fails if empty.

The tail of a list. Fails if empty.

True when a list is empty.

Select a branch to continue with depending on whether the list is empty or not.

Construct a Data from a constructor index and a list of fields.

Interpret a Data as a constructor. Fails if it’s not a constructor.

Interpret a Data as a constructor and extract its fields. Slightly more efficient than using un_constr_data.

Interpret a Data as a constructor and extract its index. Slightly more efficient than using un_constr_data.

Construct a Data from a list of pairs.

Interpret a Data as a map. Fails if it’s not a map.

Construct a Data from a list of elements.

Interpret a Data as a list. Fails if it’s not a list.

Construct a Data from an integer.

Interpret a Data as a integer. Fails if it’s not an integer.

Construct a Data from a ByteArray

Interpret a Data as a bytearray. Fails if it’s not a bytearray.

Equality on Data.

Serialise a Data to bytes, using CBOR.

Select a branch to continue with based on what the Data actually is.

Construct a Data from a pair of elements.

Construct an empty list of pairs of data.

Get the first element of a pair.

Get the second element of a pair.

Calculate the blake2b-256 hash digest value of a given bytearray. Output is always 32-byte long.

Calculate the blake2b-224 hash digest value of a given bytearray. Output is always 28-byte long.

Calculate the keccak-256 hash digest value of a given bytearray. Output is always 32-byte long.

Calculate the ripemd-160 hash digest value of a given bytearray. Output is always 20-byte long.

Calculate the SHA2-256 hash digest value of a given bytearray. Output is always 32-byte long.

Calculate the SHA3-256 hash digest value of a given bytearray. Output is always 32-byte long.

Verify an Ed25519 signature from a associated verification key.

Verify an ECDSA-SECP256k1 signature from a associated verification key.

Verify a SCHNORR-SECP256k1 signature from a associated verification key.

Continue with the continuation when the given term is Void.

Trace the provided message, and continue with the continuation.

Return first computation when the condition is true, and the second otherwise.