shelley.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, 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
;     reward_account = 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'

block = [header
        , transaction_bodies : [* transaction_body]
        , transaction_witness_sets : [* transaction_witness_set]
        , transaction_metadata_set : {* transaction_index => transaction_metadata}]

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

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

coin = uint

dns_name = text .size (0 .. 64)

epoch = uint

genesis_delegate_hash = $hash28

genesishash = $hash28

header = [header_body, body_signature : $kes_signature]

header_body = [block_number : uint
              , slot : uint
              , prev_hash : $hash32 / nil
              , issuer_vkey : $vkey
              , vrf_vkey : $vrf_vkey
              , nonce_vrf : $vrf_cert
              , leader_vrf : $vrf_cert
              , block_body_size : uint .size 4
              , block_body_hash : $hash32
              , operational_cert
              , protocol_version]

ipv4 = bytes .size 4

ipv6 = bytes .size 16

major_protocol_version = 1 .. 3

metadata_hash = $hash32

move_instantaneous_reward = [0 / 1, {* stake_credential => coin}]

multisig_script = [multisig_pubkey
                   // multisig_all
                   // multisig_any
                   // multisig_n_of_k]

nonce = [0 // 1, bytes .size 32]

nonnegative_interval = #6.30([uint, positive_int])

pool_keyhash = $hash28

pool_metadata = [url, metadata_hash]

port = uint .le 65535

positive_int = 1 .. 18446744073709551615

proposed_protocol_parameter_updates = {* genesishash => protocol_param_update}

protocol_param_update = {? 0 : uint
                        , ? 1 : uint
                        , ? 2 : uint
                        , ? 3 : uint
                        , ? 4 : uint .size 2
                        , ? 5 : coin
                        , ? 6 : coin
                        , ? 7 : epoch
                        , ? 8 : uint
                        , ? 9 : nonnegative_interval
                        , ? 10 : unit_interval
                        , ? 11 : unit_interval
                        , ? 12 : unit_interval
                        , ? 13 : nonce
                        , ? 14 : [protocol_version]
                        , ? 15 : coin}

relay = [single_host_addr // single_host_name // multi_host_name]

reward_account = h'E090000000000000000000000000000000000000000000000000000000'
                  / h'F0A0000000000000000000000000000000000000000000000000000000'

scripthash = $hash28

signkeyKES = bytes .size 64

stake_credential = [0, addr_keyhash // 1, scripthash]

transaction = [transaction_body
              , transaction_witness_set
              , transaction_metadata / nil]

transaction_body = {0 : set<transaction_input>
                   , 1 : [* transaction_output]
                   , 2 : coin
                   , 3 : uint
                   , ? 4 : [* certificate]
                   , ? 5 : withdrawals
                   , ? 6 : update
                   , ? 7 : metadata_hash}

transaction_index = uint .size 2

transaction_input = [transaction_id : $hash32, index : uint]

transaction_metadata = {* transaction_metadatum_label => transaction_metadatum}

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

transaction_metadatum_label = uint

transaction_output = [address, amount : coin]

transaction_witness_set = {? 0 : [* vkeywitness]
                          , ? 1 : [* multisig_script]
                          , ? 2 : [* bootstrap_witness]}

unit_interval = #6.30([1, 2])

update = [proposed_protocol_parameter_updates, epoch]

url = text .size (0 .. 64)

vkeywitness = [$vkey, $signature]

vrf_keyhash = $hash32

withdrawals = {* reward_account => coin}

genesis_key_delegation = (5, genesishash, genesis_delegate_hash, vrf_keyhash)

move_instantaneous_rewards_cert = (6, move_instantaneous_reward)

multi_host_name = (2, dns_name)

multisig_all = (1, [* multisig_script])

multisig_any = (2, [* multisig_script])

multisig_n_of_k = (3, uint, [* multisig_script])

multisig_pubkey = (0, addr_keyhash)

operational_cert = ($kes_vkey, uint, uint, $signature)

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)

protocol_version = (major_protocol_version, uint)

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

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)

set<a0> = [* a0]