babbage.cddl

; This file was auto-generated from huddle. Please do not modify it directly!
; Pseudo-rule introduced by Cuddle to collect root elements
huddle_root_defs = [block, transaction, $kes_signature, language, signkeyKES]

$hash28 = bytes .size 28

$hash32 = bytes .size 32

$kes_signature = bytes .size 448

$kes_vkey = bytes .size 32

$signature = bytes .size 64

$vkey = bytes .size 32

$vrf_cert = [bytes, bytes .size 80]

$vrf_vkey = bytes .size 32

addr_keyhash = $hash28

; address = bytes
; 
; address format:
;   [ 8 bit header | payload ];
; 
; shelley payment addresses:
;      bit 7: 0
;      bit 6: base/other
;      bit 5: pointer/enterprise [for base: stake cred is keyhash/scripthash]
;      bit 4: payment cred is keyhash/scripthash
;   bits 3-0: network id
; 
; reward addresses:
;   bits 7-5: 111
;      bit 4: credential is keyhash/scripthash
;   bits 3-0: network id
; 
; byron addresses:
;   bits 7-4: 1000
; 
;      0000: base address: keyhash28,keyhash28
;      0001: base address: scripthash28,keyhash28
;      0010: base address: keyhash28,scripthash28
;      0011: base address: scripthash28,scripthash28
;      0100: pointer address: keyhash28, 3 variable length uint
;      0101: pointer address: scripthash28, 3 variable length uint
;      0110: enterprise address: keyhash28
;      0111: enterprise address: scripthash28
;      1000: byron address
;      1110: reward account: keyhash28
;      1111: reward account: scripthash28
; 1001-1101: future formats
; 
address = h'001000000000000000000000000000000000000000000000000000000011000000000000000000000000000000000000000000000000000000'
           / h'102000000000000000000000000000000000000000000000000000000022000000000000000000000000000000000000000000000000000000'
           / h'203000000000000000000000000000000000000000000000000000000033000000000000000000000000000000000000000000000000000000'
           / h'304000000000000000000000000000000000000000000000000000000044000000000000000000000000000000000000000000000000000000'
           / h'405000000000000000000000000000000000000000000000000000000087680203'
           / h'506000000000000000000000000000000000000000000000000000000087680203'
           / h'6070000000000000000000000000000000000000000000000000000000'
           / h'7080000000000000000000000000000000000000000000000000000000'

asset_name = bytes .size (0 .. 32)

;               metadata: shelley
;   transaction_metadata: shelley-ma
; #6.259(0 ==> metadata): alonzo onwards
; NEW:
;   3: [* plutus_v2_script]
; 
auxiliary_data = metadata
                  / [transaction_metadata : metadata
                    , auxiliary_scripts : auxiliary_scripts]
                  / #6.259({? 0 : metadata
                           , ? 1 : [* native_script]
                           , ? 2 : [* plutus_v1_script]
                           , ? 3 : [* plutus_v2_script]})

auxiliary_data_hash = $hash32

auxiliary_scripts = [* native_script]

; NEW
;   datum_option
;   script_ref
; 
babbage_transaction_output = {0 : address
                             , 1 : value
                             , ? 2 : datum_option
                             , ? 3 : script_ref}

big_int = int / big_uint / big_nint

big_nint = #6.3(bounded_bytes)

big_uint = #6.2(bounded_bytes)

; Valid blocks must also satisfy the following two constraints:
;   1) the length of transaction_bodies and transaction_witness_sets must be
;      the same
;   2) every transaction_index must be strictly smaller than the length of
;      transaction_bodies
; 
block = [header
        , transaction_bodies : [* transaction_body]
        , transaction_witness_sets : [* transaction_witness_set]
        , auxiliary_data_set : {* transaction_index => auxiliary_data}
        , invalid_transactions : [* transaction_index]]

bootstrap_witness = [public_key : $vkey
                    , signature : $signature
                    , chain_code : bytes .size 32
                    , attributes : bytes]

; The real bounded_bytes does not have this limit. it instead has
; a different limit which cannot be expressed in CDDL.
; 
; The limit is as follows:
;  - bytes with a definite-length encoding are limited to size 0..64
;  - for bytes with an indefinite-length CBOR encoding, each chunk is
;    limited to size 0..64
;  ( reminder: in CBOR, the indefinite-length encoding of
;  bytestrings consists of a token #2.31 followed by a sequence
;  of definite-length encoded bytestrings and a stop code )
; 
bounded_bytes = bytes .size (0 .. 64)

certificate = [stake_registration
               // stake_deregistration
               // stake_delegation
               // pool_registration
               // pool_retirement
               // genesis_key_delegation
               // move_instantaneous_rewards_cert]

coin = uint

; 0: Plutus v1
; 1: Plutus v2
; 
cost_models = {? 0 : [166*166 int64], ? 1 : [175*175 int64]}

credential = [0, addr_keyhash // 1, script_hash]

data = #6.24(bytes .cbor plutus_data)

datum_option = [0, $hash32 // 1, data]

; This too has been introduced in Shelley as a backport from Alonzo.
; 
delta_coin = int

dns_name = text .size (0 .. 64)

epoch = uint

ex_unit_prices = [mem_price : positive_interval, step_price : positive_interval]

ex_units = [mem : uint, steps : uint]

genesis_delegate_hash = $hash28

genesis_hash = $hash28

header = [header_body, body_signature : $kes_signature]

;  block_body_size: merkle triple root
;       vrf_result: NEW, replaces nonce_vrf and leader_vrf
; 
header_body = [block_number : uint
              , slot : uint
              , prev_hash : $hash32 / nil
              , issuer_vkey : $vkey
              , vrf_vkey : $vrf_vkey
              , vrf_result : $vrf_cert
              , block_body_size : uint
              , block_body_hash : $hash32
              , operational_cert
              , protocol_version]

int64 = -9223372036854775808 .. 9223372036854775807

ipv4 = bytes .size 4

ipv6 = bytes .size 16

; 0: Plutus v1
; 1: Plutus v2
; 
language = 0 / 1

major_protocol_version = 1 .. 9

metadata = {* transaction_metadatum_label => transaction_metadatum}

metadata_hash = $hash32

mint = multiasset<int64>

; The first field determines where the funds are drawn from.
;   0 denotes the reserves,
;   1 denotes the treasury.
; If the second field is a map, funds are moved to stake credentials.
; Otherwise, the funds are given to the other accounting pot.
; NOTE:
;   This has been safely backported to Shelley from Alonzo.
; 
move_instantaneous_reward = [0 / 1, {* stake_credential => delta_coin} / coin]

; Timelock validity intervals are half-open intervals [a, b).
; 
;   invalid_before:
;     specifies the left (included) endpoint a.
; 
;   invalid_hereafter:
;     specifies the right (excluded) endpoint b.
; 
native_script = [script_pubkey
                 // script_all
                 // script_any
                 // script_n_of_k
                 // invalid_before
                 // invalid_hereafter]

network_id = 0 / 1

nonnegative_interval = #6.30([uint, positive_int])

plutus_data = constr<plutus_data>
               / {* plutus_data => plutus_data}
               / [* plutus_data]
               / big_int
               / bounded_bytes

plutus_v1_script = bytes

plutus_v2_script = bytes

policy_id = script_hash

pool_keyhash = $hash28

pool_metadata = [url, metadata_hash]

port = uint .le 65535

positive_int = 1 .. 18446744073709551615

positive_interval = #6.30([positive_int, positive_int])

proposed_protocol_parameter_updates = {* genesis_hash => protocol_param_update}

;  0: minfee A
;  1: minfee B
;  2: max block body size
;  3: max transaction size
;  4: max block header size
;  5: key deposit
;  6: pool deposit
;  7: maximum epoch
;  8: n_opt: desired number of stake pools
;  9: pool pledge influence
; 10: expansion rate
; 11: treasury growth rate
; 14: protocol version
; 16: min pool cost
; 17: ada per utxo byte
; 18: cost models for script languages
; 19: execution costs
; 20: max tx ex units
; 21: max block ex units
; 22: max value size
; 23: collateral percentage
; 24: max collateral inputs
; 
protocol_param_update = {? 0 : uint
                        , ? 1 : uint
                        , ? 2 : uint .size 4
                        , ? 3 : uint .size 4
                        , ? 4 : uint .size 2
                        , ? 5 : coin
                        , ? 6 : coin
                        , ? 7 : epoch
                        , ? 8 : uint .size 2
                        , ? 9 : nonnegative_interval
                        , ? 10 : unit_interval
                        , ? 11 : unit_interval
                        , ? 14 : protocol_version
                        , ? 16 : coin
                        , ? 17 : coin
                        , ? 18 : cost_models
                        , ? 19 : ex_unit_prices
                        , ? 20 : ex_units
                        , ? 21 : ex_units
                        , ? 22 : uint
                        , ? 23 : uint
                        , ? 24 : uint}

protocol_version = [major_protocol_version, uint]

; NEW
redeemer = [tag : redeemer_tag
           , index : uint
           , data : plutus_data
           , ex_units : ex_units]

; 0: spend
; 1: mint
; 2: cert
; 3: reward
; 
redeemer_tag = 0 / 1 / 2 / 3

redeemers = [* redeemer]

relay = [single_host_addr // single_host_name // multi_host_name]

required_signers = set<addr_keyhash>

; reward_account = bytes
; 
reward_account = h'E090000000000000000000000000000000000000000000000000000000'
                  / h'F0A0000000000000000000000000000000000000000000000000000000'

script = [0, native_script // 1, plutus_v1_script // 2, plutus_v2_script]

; This is a hash of data which may affect evaluation of a script.
; This data consists of:
;   - The redeemers from the transaction_witness_set (the value of field 5).
;   - The datums from the transaction_witness_set (the value of field 4).
;   - The value in the costmdls map corresponding to the script's language
;     (in field 18 of protocol_param_update.)
; (In the future it may contain additional protocol parameters.)
; 
; Since this data does not exist in contiguous form inside a transaction, it needs
; to be independently constructed by each recipient.
; 
; The bytestring which is hashed is the concatenation of three things:
;   redeemers || datums || language views
; The redeemers are exactly the data present in the transaction witness set.
; Similarly for the datums, if present. If no datums are provided, the middle
; field is omitted (i.e. it is the empty/null bytestring).
; 
; language views CDDL:
; { * language => script_integrity_data }
; 
; This must be encoded canonically, using the same scheme as in
; RFC7049 section 3.9:
;  - Maps, strings, and bytestrings must use a definite-length encoding
;  - Integers must be as small as possible.
;  - The expressions for map length, string length, and bytestring length
;    must be as short as possible.
;  - The keys in the map must be sorted as follows:
;     -  If two keys have different lengths, the shorter one sorts earlier.
;     -  If two keys have the same length, the one with the lower value
;        in (byte-wise) lexical order sorts earlier.
; 
; For PlutusV1 (language id 0), the language view is the following:
;   - the value of costmdls map at key 0 (in other words, the script_integrity_data)
;     is encoded as an indefinite length list and the result is encoded as a bytestring.
;     (our apologies)
;     For example, the script_integrity_data corresponding to the all zero costmodel for V1
;     would be encoded as (in hex):
;     58a89f00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ff
;   - the language ID tag is also encoded twice. first as a uint then as
;     a bytestring. (our apologies)
;     Concretely, this means that the language version for V1 is encoded as
;     4100 in hex.
; For PlutusV2 (language id 1), the language view is the following:
;   - the value of costmdls map at key 1 is encoded as an definite length list.
;     For example, the script_integrity_data corresponding to the all zero costmodel for V2
;     would be encoded as (in hex):
;     98af0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
;   - the language ID tag is encoded as expected.
;     Concretely, this means that the language version for V2 is encoded as
;     01 in hex.
; 
; Note that each Plutus language represented inside a transaction must have
; a cost model in the costmdls protocol parameter in order to execute,
; regardless of what the script integrity data is.
; 
; Finally, note that in the case that a transaction includes datums but does not
; include the redeemers field, the script data format becomes (in hex):
; [ 80 | datums | A0 ]
; corresponding to a CBOR empty list and an empty map.
; Note that a transaction might include the redeemers field and set it to the
; empty map, in which case the user supplied encoding of the empty map is used.
; 
script_data_hash = $hash32

; To compute a script hash, note that you must prepend
; a tag to the bytes of the script before hashing.
; The tag is determined by the language.
; The tags in the Conway era are:
;   "\x00" for multisig scripts
;   "\x01" for Plutus V1 scripts
;   "\x02" for Plutus V2 scripts
;   "\x03" for Plutus V3 scripts
; 
script_hash = $hash28

script_ref = #6.24(bytes .cbor script)

shelley_transaction_output = [address, amount : value, ? datum_hash : $hash32]

signkeyKES = bytes .size 64

stake_credential = credential

transaction = [transaction_body
              , transaction_witness_set
              , bool
              , auxiliary_data / nil]

;  2: fee
;  3: time to live
;  8: validity interval start
; 13: collateral inputs
; NEW:
;   16: collateral return
;   17: total collateral
;   18: reference inputs
; 
transaction_body = {0 : set<transaction_input>
                   , 1 : [* transaction_output]
                   , 2 : coin
                   , ? 3 : uint
                   , ? 4 : [* certificate]
                   , ? 5 : withdrawals
                   , ? 6 : update
                   , ? 7 : auxiliary_data_hash
                   , ? 8 : uint
                   , ? 9 : mint
                   , ? 11 : script_data_hash
                   , ? 13 : set<transaction_input>
                   , ? 14 : required_signers
                   , ? 15 : network_id
                   , ? 16 : transaction_output
                   , ? 17 : coin
                   , ? 18 : set<transaction_input>}

transaction_index = uint .size 2

transaction_input = [transaction_id : $hash32, index : uint .size 2]

transaction_metadatum = {* transaction_metadatum => transaction_metadatum}
                         / [* transaction_metadatum]
                         / int
                         / bytes .size (0 .. 64)
                         / text .size (0 .. 64)

transaction_metadatum_label = uint

; Both of the Alonzo and Babbage style TxOut formats are equally valid
; and can be used interchangeably.
; NEW:
;   babbage_transaction_output
; 
transaction_output = shelley_transaction_output / babbage_transaction_output

; 
; NEW:
;   6: [* plutus_v2_script]
; 
transaction_witness_set = {? 0 : [* vkeywitness]
                          , ? 1 : [* native_script]
                          , ? 2 : [* bootstrap_witness]
                          , ? 3 : [* plutus_v1_script]
                          , ? 4 : [* plutus_data]
                          , ? 5 : redeemers
                          , ? 6 : [* plutus_v2_script]}

; The real unit_interval is: #6.30([uint, uint])
; 
; A unit interval is a number in the range between 0 and 1, which
; means there are two extra constraints:
;   1. numerator <= denominator
;   2. denominator > 0
; 
; The relation between numerator and denominator can be
; expressed in CDDL, but we have a limitation currently
; (see: https://github.com/input-output-hk/cuddle/issues/30)
; which poses a problem for testing. We need to be able to
; generate random valid data for testing implementation of
; our encoders/decoders. Which means we cannot use the actual
; definition here and we hard code the value to 1/2
; 
unit_interval = #6.30([1, 2])

update = [proposed_protocol_parameter_updates, epoch]

url = text .size (0 .. 64)

value = coin / [coin, multiasset<uint>]

vkeywitness = [$vkey, $signature]

vrf_keyhash = $hash32

withdrawals = {* reward_account => coin}

genesis_key_delegation = (5, genesis_hash, genesis_delegate_hash, vrf_keyhash)

invalid_before = (4, uint)

invalid_hereafter = (5, uint)

move_instantaneous_rewards_cert = (6, move_instantaneous_reward)

; dns_name: An SRV DNS record
; 
multi_host_name = (2, dns_name)

;  kes_vkey: hot_vkey
;      uint: sequence_number
;      uint: key_period
; signature: sigma
; 
operational_cert = ($kes_vkey, uint, uint, $signature)

;         pool_keyhash: operator
;                 coin: pledge
;                 coin: cost
;        unit_interval: margin
;    set<addr_keyhash>: pool_owners
; 
pool_params = (pool_keyhash
              , vrf_keyhash
              , coin
              , coin
              , unit_interval
              , reward_account
              , set<addr_keyhash>
              , [* relay]
              , pool_metadata / nil)

pool_registration = (3, pool_params)

pool_retirement = (4, pool_keyhash, epoch)

script_all = (1, [* native_script])

script_any = (2, [* native_script])

script_n_of_k = (3, uint, [* native_script])

script_pubkey = (0, addr_keyhash)

single_host_addr = (0, port / nil, ipv4 / nil, ipv6 / nil)

; dns_name: An A or AAAA DNS record
; 
single_host_name = (1, port / nil, dns_name)

stake_delegation = (2, stake_credential, pool_keyhash)

; This will be deprecated in a future era
stake_deregistration = (1, stake_credential)

; This will be deprecated in a future era
stake_registration = (0, stake_credential)

constr<a0> = #6.121([* a0])
              / #6.122([* a0])
              / #6.123([* a0])
              / #6.124([* a0])
              / #6.125([* a0])
              / #6.126([* a0])
              / #6.127([* a0])
              / #6.102([uint, [* a0]])

multiasset<a0> = {* policy_id => {* asset_name => a0}}

set<a0> = [* a0]