DefaultFun

Add two integers.

'''Type:''' Integer -> Integer -> Integer

Bitwise AND of two bytestrings.

'''Type:''' Bool -> ByteString -> ByteString -> ByteString

The Bool controls padding behavior for different-length inputs:

• false: result has length of shorter input (truncating)
• true: result has length of longer input (padding with remaining bytes)

Concatenate two bytestrings.

'''Type:''' ByteString -> ByteString -> ByteString

Concatenate two strings.

'''Type:''' String -> String -> String

Construct a Data value representing a bytestring.

'''Type:''' ByteString -> Data

Compute BLAKE2b-224 hash.

'''Type:''' ByteString -> ByteString

Produces a 28-byte (224-bit) hash digest.

Compute BLAKE2b-256 hash.

'''Type:''' ByteString -> ByteString

Produces a 32-byte (256-bit) hash digest. This is the primary hash function used in Cardano for script hashing and transaction IDs.

Add two G1 curve points.

'''Type:''' G1_Element -> G1_Element -> G1_Element

Compress a G1 point to 48 bytes.

'''Type:''' G1_Element -> ByteString

Check equality of two G1 points.

'''Type:''' G1_Element -> G1_Element -> Bool

Hash arbitrary data to a G1 curve point.

'''Type:''' ByteString -> ByteString -> G1_Element

Uses hash-to-curve with a domain separation tag (DST). First argument is the message, second is the DST.

Multi-scalar multiplication on G1.

'''Type:''' [Integer] -> [G1_Element] -> G1_Element

Computes the sum ∑(i=0 to N-1) scalar_i × point_i efficiently using Pippenger's algorithm. Both input lists must be non-empty and have equal length.

Negate a G1 curve point.

'''Type:''' G1_Element -> G1_Element

Scalar multiplication on G1.

'''Type:''' Integer -> G1_Element -> G1_Element

Multiplies the point by a scalar integer.

Decompress a 48-byte representation to a G1 point.

'''Type:''' ByteString -> G1_Element

Add two G2 curve points.

'''Type:''' G2_Element -> G2_Element -> G2_Element

Compress a G2 point to 96 bytes.

'''Type:''' G2_Element -> ByteString

Check equality of two G2 points.

'''Type:''' G2_Element -> G2_Element -> Bool

Hash arbitrary data to a G2 curve point.

'''Type:''' ByteString -> ByteString -> G2_Element

Multi-scalar multiplication on G2.

'''Type:''' [Integer] -> [G2_Element] -> G2_Element

Computes the sum ∑(i=0 to N-1) scalar_i × point_i efficiently using Pippenger's algorithm. Both input lists must be non-empty and have equal length.

Negate a G2 curve point.

'''Type:''' G2_Element -> G2_Element

Scalar multiplication on G2.

'''Type:''' Integer -> G2_Element -> G2_Element

Decompress a 96-byte representation to a G2 point.

'''Type:''' ByteString -> G2_Element

Perform final pairing verification.

'''Type:''' MlResult -> MlResult -> Bool

Returns true if the final exponentiation of both results are equal, i.e., checks that e(P1, Q1) * ... = e(P2, Q2) * ....

Compute the Miller loop for pairing.

'''Type:''' G1_Element -> G2_Element -> MlResult

Computes the intermediate pairing result, which can be combined with mulMlResult and verified with finalVerify.

Multiply two Miller loop results.

'''Type:''' MlResult -> MlResult -> MlResult

Used to combine multiple pairing computations before final verification.

Convert a bytestring to an unsigned integer.

'''Type:''' Bool -> ByteString -> Integer

Parameters:

• Bool: true for big-endian, false for little-endian
• ByteString: the bytes to interpret as an unsigned integer

Pattern match on the Data type.

'''Type:''' ∀a. Data -> a -> a -> a -> a -> a -> a

Requires one force application. Arguments after Data are: constr case, map case, list case, integer case, bytestring case. Returns the argument corresponding to the Data constructor.

Pattern match on a list (empty vs non-empty).

'''Type:''' ∀a b. List a -> b -> b -> b

Requires two force applications. Returns the second argument if the list is empty, third argument otherwise.

Choose based on unit value.

'''Type:''' ∀a. Unit -> a -> a

Requires one force to instantiate the type variable. Always returns the second argument after evaluating the first (which must be unit).

Bitwise complement (NOT) of a bytestring.

'''Type:''' ByteString -> ByteString

Inverts all bits in the bytestring.

Prepend a byte to a bytestring.

'''Type:''' Integer -> ByteString -> ByteString

The integer must be in the range [0, 255].

Construct a Data value representing a constructor application.

'''Type:''' Integer -> List Data -> Data

Count the number of set bits (population count).

'''Type:''' ByteString -> Integer

Decode UTF-8 bytes to a string.

'''Type:''' ByteString -> String

Divide two integers using floor division (truncate toward negative infinity).

'''Type:''' Integer -> Integer -> Integer

For negative dividends with positive divisors (or vice versa), this differs from truncated division (quotientInteger) by rounding toward negative infinity.

Drop the first n elements from a list.

'''Type:''' ∀a. Integer -> List a -> List a

Requires one force application. If n is negative, returns the original list. If n exceeds the list length, returns an empty list.

Encode a string as UTF-8 bytes.

'''Type:''' String -> ByteString

Check if two bytestrings are equal.

'''Type:''' ByteString -> ByteString -> Bool

Check if two Data values are equal.

'''Type:''' Data -> Data -> Bool

Performs deep structural equality comparison.

Check if two integers are equal.

'''Type:''' Integer -> Integer -> Bool

Check if two strings are equal.

'''Type:''' String -> String -> Bool

Compute modular exponentiation.

'''Type:''' Integer -> Integer -> Integer -> Integer

Computes base^exponent mod modulus. Supports negative exponents via modular inverse.

Parameters:

• base: the base integer
• exponent: the exponent (can be negative if base is invertible mod modulus)
• modulus: the modulus (must be positive)

Semantics:

• If modulus <= 0: error
• If modulus == 1: returns 0
• If exponent >= 0: returns base^exponent mod modulus
• If exponent < 0 and gcd(base, modulus) == 1: returns (base^(-1))^(-exponent) mod modulus
• If exponent < 0 and gcd(base, modulus) != 1: error (base not invertible)

Find the index of the first set bit.

'''Type:''' ByteString -> Integer

Returns -1 if no bits are set. Index 0 is the least significant bit.

Extract the first element of a pair.

'''Type:''' ∀a b. Pair a b -> a

Requires two force applications to instantiate both type variables.

Get the first element of a non-empty list.

'''Type:''' ∀a. List a -> a

Requires one force application.

Construct a Data value representing an integer.

'''Type:''' Integer -> Data

Conditional expression (if-then-else).

'''Type:''' ∀a. Bool -> a -> a -> a

Requires one force to instantiate the type variable. Returns the second argument if the condition is true, third argument otherwise.

Access an element by index.

'''Type:''' ∀a. Array a -> Integer -> a

Requires one force application.

Get the byte at a specific index in a bytestring.

'''Type:''' ByteString -> Integer -> Integer

Returns an unsigned byte value in [0, 255]. Index is 0-based.

Insert or update a token amount in a Value.

'''Type:''' ByteString -> ByteString -> Integer -> Value -> Value

Parameters: currency symbol (policy ID, max 32 bytes), token name (max 32 bytes), amount, and the Value to modify. Use amount 0 to remove a token.

Convert an integer to a bytestring.

'''Type:''' Bool -> Integer -> Integer -> ByteString

Parameters:

• First Bool: true for big-endian, false for little-endian
• First Integer: target length in bytes (0 for minimal representation)
• Second Integer: the unsigned integer to convert (must be non-negative)

Compute Keccak-256 hash.

'''Type:''' ByteString -> ByteString

Produces a 32-byte hash. This is the hash function used by Ethereum.

Get the length of an array.

'''Type:''' ∀a. Array a -> Integer

Requires one force application.

Get the length of a bytestring in bytes.

'''Type:''' ByteString -> Integer

Check if the first bytestring is lexicographically less than the second.

'''Type:''' ByteString -> ByteString -> Bool

Comparison is byte-by-byte, treating bytes as unsigned. Shorter bytestrings are considered less than longer ones with the same prefix.

Check if the first bytestring is lexicographically less than or equal to the second.

'''Type:''' ByteString -> ByteString -> Bool

Check if the first integer is less than or equal to the second.

'''Type:''' Integer -> Integer -> Bool

Check if the first integer is strictly less than the second.

'''Type:''' Integer -> Integer -> Bool

Construct a Data value representing a list.

'''Type:''' List Data -> Data

Convert a list to an array.

'''Type:''' ∀a. List a -> Array a

Requires one force application.

Look up a token amount in a Value.

'''Type:''' ByteString -> ByteString -> Value -> Integer

Returns 0 if the token is not present.

Construct a Data value representing a map.

'''Type:''' List (Pair Data Data) -> Data

Prepend an element to a list.

'''Type:''' ∀a. a -> List a -> List a

Requires one force application.

Create an empty list of Data values.

'''Type:''' Unit -> List Data

Create an empty list of Data pairs.

'''Type:''' Unit -> List (Pair Data Data)

Useful for constructing empty maps.

Create a pair of Data values.

'''Type:''' Data -> Data -> Pair Data Data

This is a monomorphized version of pair construction for Data.

Compute the modulus after floor division (divideInteger).

'''Type:''' Integer -> Integer -> Integer

The result has the same sign as the divisor. Satisfies: dividend = divideInteger(dividend, divisor) * divisor + modInteger(dividend, divisor)

Access multiple elements by indices.

'''Type:''' ∀a. List Integer -> Array a -> List a

Requires one force application. Returns elements at the specified indices in order.

Multiply two integers.

'''Type:''' Integer -> Integer -> Integer

Check if a list is empty.

'''Type:''' ∀a. List a -> Bool

Requires one force application.

Bitwise OR of two bytestrings.

'''Type:''' Bool -> ByteString -> ByteString -> ByteString

Compute the quotient of two integers (truncate toward zero).

'''Type:''' Integer -> Integer -> Integer

This is standard truncated division, which rounds toward zero.

Read a single bit from a bytestring.

'''Type:''' ByteString -> Integer -> Bool

Bit indexing starts from the end (least significant bit of last byte is index 0).

Compute the remainder after truncated division (quotientInteger).

'''Type:''' Integer -> Integer -> Integer

The result has the same sign as the dividend. Satisfies: dividend = quotientInteger(dividend, divisor) * divisor + remainderInteger(dividend, divisor)

Create a bytestring by repeating a byte value.

'''Type:''' Integer -> Integer -> ByteString

First integer is length, second is the byte value [0, 255].

Compute RIPEMD-160 hash.

'''Type:''' ByteString -> ByteString

Produces a 20-byte (160-bit) hash digest. Used in Bitcoin address derivation.

Rotate bits in a bytestring.

'''Type:''' ByteString -> Integer -> ByteString

Positive rotation moves bits left; bits shifted out wrap around to the right.

Scale all token amounts in a Value by a multiplier.

'''Type:''' Integer -> Value -> Value

Serialize a Data value to CBOR bytes.

'''Type:''' Data -> ByteString

Produces CBOR-encoded representation of the Data value.

Compute SHA2-256 hash.

'''Type:''' ByteString -> ByteString

Produces a 32-byte (256-bit) hash digest.

Compute SHA3-256 hash.

'''Type:''' ByteString -> ByteString

Produces a 32-byte (256-bit) hash digest using the Keccak-based SHA3.

Shift bits in a bytestring.

'''Type:''' ByteString -> Integer -> ByteString

Positive shift moves bits left (toward higher indices), negative moves right. Bits shifted out are lost; new bits are zero.

Extract a slice from a bytestring.

'''Type:''' Integer -> Integer -> ByteString -> ByteString

Parameters are: start index (inclusive), length, and source bytestring. If start is beyond the end, returns empty. If length exceeds available bytes, returns as many bytes as available.

Extract the second element of a pair.

'''Type:''' ∀a b. Pair a b -> b

Requires two force applications to instantiate both type variables.

Subtract two integers.

'''Type:''' Integer -> Integer -> Integer

Get all elements except the first from a non-empty list.

'''Type:''' ∀a. List a -> List a

Requires one force application.

Trace a message and return a value.

'''Type:''' ∀a. String -> a -> a

Requires one force to instantiate the type variable. Logs the string message (for debugging) and returns the second argument unchanged.

Extract the bytestring from a ByteString Data value.

'''Type:''' Data -> ByteString

Extract constructor index and arguments from a Constr Data value.

'''Type:''' Data -> Pair Integer (List Data)

Extract the integer from an Integer Data value.

'''Type:''' Data -> Integer

Extract the list from a List Data value.

'''Type:''' Data -> List Data

Extract the map from a Map Data value.

'''Type:''' Data -> List (Pair Data Data)

Convert Data to a Value.

'''Type:''' Data -> Value

The Data must have the structure Map ByteString (Map ByteString Integer).

Merge two Values by adding corresponding token amounts.

'''Type:''' Value -> Value -> Value

Check if one Value contains at least the amounts in another.

'''Type:''' Value -> Value -> Bool

Returns true if the first Value has at least as much of every token as the second Value.

Convert a Value to its Data representation.

'''Type:''' Value -> Data

Verify an ECDSA signature on the secp256k1 curve.

'''Type:''' ByteString -> ByteString -> ByteString -> Bool

Parameters are: public key (33 bytes compressed), message hash (32 bytes), signature (64 bytes, r||s format).

Verify an Ed25519 signature.

'''Type:''' ByteString -> ByteString -> ByteString -> Bool

Parameters are: public key (32 bytes), message, signature (64 bytes).

Verify a Schnorr signature on the secp256k1 curve (BIP-340).

'''Type:''' ByteString -> ByteString -> ByteString -> Bool

Parameters are: public key (32 bytes x-only), message (arbitrary), signature (64 bytes).

Write multiple bits in a bytestring.

'''Type:''' ByteString -> List Integer -> Bool -> ByteString

Sets all bits at the specified indices to the given boolean value.

Bitwise XOR of two bytestrings.

'''Type:''' Bool -> ByteString -> ByteString -> ByteString