An opaque type representing Plutus Core ByteStrings.

Perform logical AND on two BuiltinByteString arguments, as described in CIP-122.

The first argument indicates whether padding semantics should be used or not; if False, truncation semantics will be used instead.

See also

• Padding and truncation semantics
• Bit indexing scheme

Perform logical OR on two BuiltinByteString arguments, as described here.

The first argument indicates whether padding semantics should be used or not; if False, truncation semantics will be used instead.

See also

• Padding and truncation semantics
• Bit indexing scheme

Perform logical XOR on two BuiltinByteString arguments, as described here.

The first argument indicates whether padding semantics should be used or not; if False, truncation semantics will be used instead.

See also

• Padding and truncation semantics
• Bit indexing scheme

Perform logical complement on a BuiltinByteString, as described here.

See also

• Bit indexing scheme

Read a bit at the _bit_ index given by the Integer argument in the BuiltinByteString argument. The result will be True if the corresponding bit is set, and False if it is clear. Will error if given an out-of-bounds index argument; that is, if the index is either negative, or equal to or greater than the total number of bits in the BuiltinByteString argument.

See also

• Bit indexing scheme
• Operation description

Given a BuiltinByteString, a list of indexes to change, and a boolean value b to change those indexes to, set the bit at each of the specified index as follows:

• If b is True, set that bit;
• Otherwise, clear that bit.

Will error if any of the indexes are out-of-bounds: that is, if the index is either negative, or equal to or greater than the total number of bits in the BuiltinByteString argument.

Note

This differs slightly from the description of the corresponding operation in CIP-122; instead of a single changelist argument comprised of pairs, we instead pass a single list of indexes to change, and a single boolean value to change those indexes to. The original proposal allowed one to set and clear bits in a single operation, but constructing the list of boolean values for the updates was somewhat expensive. If it's really necessary to set some bits and clear others then it is easier to call the function twice, once to set bits and and once to clear them.

See also

• Bit indexing scheme
• Operation description

Given a length (first argument) and a byte (second argument), produce a BuiltinByteString of that length, with that byte in every position. Will error if given a negative length, or a second argument that isn't a byte (less than 0, greater than 255).

See also

• Operation description

Shift a BuiltinByteString, as per CIP-123.

Rotate a BuiltinByteString, as per CIP-123.

Count the set bits in a BuiltinByteString, as per CIP-123.

Find the lowest index of a set bit in a BuiltinByteString, as per CIP-123.

If given a BuiltinByteString which consists only of zero bytes (including the empty BuiltinByteString, this returns -1.

The SHA2-256 hash of a ByteString

The SHA3-256 hash of a ByteString

The BLAKE2B-224 hash of a ByteString

The BLAKE2B-256 hash of a ByteString

The KECCAK-256 hash of a ByteString

The RIPEMD-160 hash of a ByteString

Ed25519 signature verification. Verify that the signature is a signature of the message by the public key. This will fail if key or the signature are not of the expected length.

Given an ECDSA SECP256k1 verification key, an ECDSA SECP256k1 signature, and an ECDSA SECP256k1 message hash (all as BuiltinByteStrings), verify the hash with that key and signature.

Note

There are additional well-formation requirements for the arguments beyond their length:

• The first byte of the public key must correspond to the sign of the y coordinate: this is 0x02 if y is even, and 0x03 otherwise.
• The remaining bytes of the public key must correspond to the x coordinate, as a big-endian integer.
• The first 32 bytes of the signature must correspond to the big-endian integer representation of _r_.
• The last 32 bytes of the signature must correspond to the big-endian integer representation of _s_.

While this primitive accepts a hash, any caller should only pass it hashes that they computed themselves: specifically, they should receive the message from a sender and hash it, rather than receiving the hash from said sender. Failure to do so can be dangerous. Other than length, we make no requirements of what hash gets used.

See also

• secp256k1_ec_pubkey_serialize; this implements the format for the verification key that we accept, given a length argument of 33 and the SECP256K1_EC_COMPRESSED flag.
• secp256k1_ecdsa_serialize_compact; this implements the format for the signature that we accept.

Given a Schnorr SECP256k1 verification key, a Schnorr SECP256k1 signature, and a message (all as BuiltinByteStrings), verify the message with that key and signature.

Note

There are additional well-formation requirements for the arguments beyond their length. Throughout, we refer to co-ordinates of the point R.

• The bytes of the public key must correspond to the x coordinate, as a big-endian integer, as specified in BIP-340.
• The first 32 bytes of the signature must correspond to the x coordinate, as a big-endian integer, as specified in BIP-340.
• The last 32 bytes of the signature must correspond to the bytes of s, as a big-endian integer, as specified in BIP-340.

See also

• BIP-340
• secp256k1_xonly_pubkey_serialize; this implements the format for the verification key that we accept.
• secp256k1_schnorrsig_sign; this implements the signing logic for signatures this builtin can verify.

Represents an arbitrary-precision ratio.

The following two invariants are maintained:

1. The denominator is greater than zero.
2. The numerator and denominator are coprime.

Makes a Rational from a numerator and a denominator.

Important note

If given a zero denominator, this function will error. If you don't mind a size increase, and care about safety, use ratio instead.

Safely constructs a Rational from a numerator and a denominator. Returns Nothing if given a zero denominator.

Converts an Integer into the equivalent Rational.

round r returns the nearest Integer value to r. If r is equidistant between two values, the even value will be given.

A type corresponding to the Plutus Core builtin equivalent of Data.

The point of this type is to be an opaque equivalent of Data, so as to ensure that it is only used in ways that the compiler can handle.

As such, you should use this type in your on-chain code, and in any data structures that you want to be representable on-chain.

For off-chain usage, there are conversion functions builtinDataToData and dataToBuiltinData, but note that these will not work on-chain.

A typeclass for types that can be converted to and from BuiltinData.

Convert a BuiltinInteger into a BuiltinByteString, as described in CIP-121. The first argument indicates the endianness of the conversion and the third argument is the integer to be converted, which must be non-negative. The second argument must also be non-negative and it indicates the required width of the output. If the width is zero then the output is the smallest bytestring which can contain the converted input (and in this case, the integer 0 encodes to the empty bytestring). If the width is nonzero then the output bytestring will be padded to the required width with 0x00 bytes (on the left for big-endian conversions and on the right for little-endian conversions); if the input integer is too big to fit into a bytestring of the specified width then the conversion will fail. Conversion will also fail if the specified width is greater than 8192 or the input integer is too big to fit into a bytestring of length 8192.

Convert a BuiltinByteString to a BuiltinInteger, as described in CIP-121. The first argument indicates the endianness of the conversion and the second is the bytestring to be converted. There is no limitation on the size of the bytestring. The empty bytestring is converted to the integer 0.