aiken/builtin

This modules contains all the Plutus builtins recognized by Aiken.

It’s important to note that many of those functions are partial and will halt the execution of the Plutus virtual machine on failure. They also all rely on call-by-value, which means that function arguments are eagerly evaluated.

Functions

add_integer(left: Int, right: Int) -> Int

Adds two integers (+).

append_bytearray(left: ByteArray, right: ByteArray) -> ByteArray

Concatenate two bytearrays together.

append_string(left: String, right: String) -> String

Concatenate two strings.

b_data(bytes: ByteArray) -> Data

Construct a Data from a ByteArray

blake2b_256(preimage: ByteArray) -> ByteArray

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

choose_data(
  data: Data,
  when_constr: a,
  when_map: a,
  when_list: a,
  when_int: a,
  when_bytearray: a,
) -> a

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

choose_list(list: List<a>, when_empty: b, when_non_empty: b) -> b

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

choose_void(void: Void, when_void: a) -> a

Continue with the continuation when the given term is Void.

cons_bytearray(byte: Int, bytes: ByteArray) -> ByteArray

Push a byte in front of a bytearray.

cons_list(elem: a, list: List<a>) -> List<a>

Push an element in front of a list.

constr_data(index: Int, fields: List<Data>) -> Data

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

debug(message: String, continuation: a) -> a

Trace the provided message, and continue with the continuation.

decode_utf8(bytes: ByteArray) -> String

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

divide_integer(numerator: Int, denominator: Int) -> Int

Integer division truncated towards negative infinity (/).

encode_utf8(str: String) -> ByteArray

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

equals_bytearray(left: ByteArray, right: ByteArray) -> Bool

Bytearray equality.

equals_data(left: Data, right: Data) -> ByteArray

Equality on Data.

equals_integer(left: Int, right: Int) -> Bool

Integer equality.

equals_string(left: String, right: String) -> Bool

String equality.

fst_pair(pair: (a, b)) -> a

Get the first element of a pair.

head_list(list: List<a>) -> a

The head of a list. Fails if empty.

i_data(i: Int) -> Data

Construct a Data from an integer.

if_then_else(condition: Bool, when_true: a, when_false: a) -> a

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

index_bytearray(bytes: ByteArray, index: Int) -> Int

Access the byte at the given index in the bytearray.

length_of_bytearray(bytes: ByteArray) -> Int

Number of bytes in a bytearray.

less_than_bytearray(left: ByteArray, right: ByteArray) -> Bool

Bytearray strict inequality.

less_than_equals_bytearray(left: ByteArray, right: ByteArray) -> Bool

Bytearray inequality.

less_than_equals_integer(left: Int, right: Int) -> Int

Integer inequality.

less_than_integer(left: Int, right: Int) -> Int

Integer strict inequality.

list_data(items: List<Data>) -> Data

Construct a Data from a list of elements.

map_data(items: List<(Data, Data)>) -> Data

Construct a Data from a list of pairs.

mk_nil_data() -> List<Data>

Construct an empty list of Data.

mk_nil_pair_data() -> List<(Data, Data)>

Construct an empty list of pairs of data.

mk_pair_data(left: Data, right: Data) -> (Data, Data)

Construct a Data from a pair of elements.

mod_integer(numerator: Int, denominator: Int) -> Int

Integer modulus (%), satisfying

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

multiply_integer(left: Int, right: Int) -> Int

Multiple two integers (*).

null_list(list: List<a>) -> Bool

True when a list is empty.

quotient_integer(numerator: Int, denominator: Int) -> Int

Integer division truncated towards zero.

remainder_integer(numerator: Int, denominator: Int) -> Int

Integer remainder, satisfying

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

serialise_data(data: Data) -> ByteArray

Serialise a Data to bytes, using CBOR.

sha2_256(preimage: ByteArray) -> ByteArray

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

sha3_256(preimage: ByteArray) -> ByteArray

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

slice_bytearray(start: Int, end: Int, bytes: ByteArray) -> ByteArray

Extract a sub-array from a bytearray given starting and ending indexes.

snd_pair(pair: (a, b)) -> b

Get the second element of a pair.

subtract_integer(left: Int, right: Int) -> Int

Subtract two integers (-).

tail_list(list: List<a>) -> List<a>

The tail of a list. Fails if empty.

un_b_data(data: Data) -> ByteArray

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

un_constr_data(data: Data) -> (Int, List<Data>)

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

un_i_data(data: Data) -> Int

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

un_list_data(data: Data) -> List<Data>

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

un_map_data(data: Data) -> List<(Data, Data)>

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

verify_ecdsa_secp256k1_signature(
  verification_key: ByteArray,
  message: ByteArray,
  signature: ByteArray,
) -> ByteArray

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

verify_ed25519_signature(
  verification_key: ByteArray,
  message: ByteArray,
  signature: ByteArray,
) -> ByteArray

Verify an Ed25519 signature from a associated verification key.

verify_schnorr_secp256k1_signature(
  verification_key: ByteArray,
  message: ByteArray,
  signature: ByteArray,
) -> ByteArray

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

Search Document