Cardano: Aiken contract scaffold (Endpoint, ULN302, Executor, DVN)

src/cardano/contracts/README.md

@@ -0,0 +1,52 @@
+# Cardano LayerZero (Aiken)
+
+This folder contains the Aiken-based Cardano implementation of LayerZero V2 core on-chain components.
+
+Contents
+- aiken/
+  - validators/
+    - endpoint.ak
+    - uln302_send.ak
+    - uln302_receive.ak
+    - executor.ak
+    - dvn.ak
+  - lib/
+    - layerzero/
+      - types.ak
+      - codec.ak
+      - constants.ak
+      - dvn_helpers.ak
+      - endpoint_helpers.ak
+  - tests/
+    - codec.tests.ak
+    - endpoint.tests.ak
+    - endpoint_validator.tests.ak
+    - uln302_send.tests.ak
+    - uln302_receive.tests.ak
+    - executor_commit.tests.ak
+    - dvn.tests.ak
+    - dvn_execute.tests.ak
+  - aiken.toml
+
+What’s implemented
+- Endpoint: per-(origin, receiver) channel UTXOs for inbound nonce and executable-state tracking.
+- ULN302 Send/Receive: config handling, header assertions, atomic Endpoint.Verify requirement, fee routing checks.
+- Executor: Commit-and-Execute with Endpoint IO atomicity and fee-output enforcement.
+- DVN: Ed25519 multisig with configurable signer set and quorum; admin flows for signer/quorum updates.
+- Codecs: Packet V1 header encoder/decoder and hashing aligned to EVM fixed-width layout.
+
+How to run
+- Install Aiken: https://aiken-lang.org/
+- From this directory:
+  - cd src/cardano/contracts/aiken
+  - aiken check
+
+This compiles and collects the test suite, which includes:
+- DVN multisig verification (positive with real Ed25519 signature) and negative cases (insufficient quorum, non-member, duplicates).
+- Endpoint nonce monotonicity and executable gating.
+- ULN302 Send outbound datum and fee routing checks.
+- Executor commit-and-execute atomicity.
+
+Notes
+- No secrets are embedded; tests use deterministic vectors.
+- Behavior mirrors LayerZero V2 EVM/altVM where applicable, adapted to Cardano’s eUTXO model.

src/cardano/contracts/aiken/aiken.lock

@@ -0,0 +1,16 @@
+# This file was generated by Aiken
+# You typically do not need to edit this file
+
+[[requirements]]
+name = "aiken-lang/stdlib"
+version = "v2"
+source = "github"
+
+[[packages]]
+name = "aiken-lang/stdlib"
+version = "v2"
+requirements = []
+source = "github"
+
+[etags]
+"aiken-lang/stdlib@v2" = [{ secs_since_epoch = 1755954588, nanos_since_epoch = 724920106 }, "25c8d0802b8266feca04b47933382c5dee3cadb422208a5d3810d9d2df108c2e"]

src/cardano/contracts/aiken/aiken.toml

@@ -0,0 +1,10 @@
+name = "LZeroAnalytics/layerzero-cardano"
+version = "0.1.0"
+plutusVersion = "v3"
+licences = ["MIT"]
+description = "LayerZero V2 core contracts adapted for Cardano in Aiken (Endpoint, ULN302, Executor, DVN)."
+
+[[dependencies]]
+name = "aiken-lang/stdlib"
+version = "v2"
+source = "github"

src/cardano/contracts/aiken/lib/layerzero/codec.ak

@@ -0,0 +1,133 @@
+use aiken/builtin
+use aiken/builtin
+use aiken/primitive/bytearray
+
+use layerzero/types
+use layerzero/types.{Address32, Address20, Eid, Nonce, Guid, PacketHeaderV1}
+
+pub fn header_hash_v1(header: ByteArray) -> ByteArray {
+  builtin.blake2b_256(header)
+}
+
+pub fn encode_address32(a) -> ByteArray {
+  let Address32(bytes) = a
+  bytes
+}
+
+pub fn encode_address20_to_bytes32(a) -> ByteArray {
+  let Address20(b20) = a
+  let pad = bytearray.from_int_big_endian(0, 12)
+  bytearray.concat(pad, b20)
+}
+
+pub fn encode_eid(a) -> ByteArray {
+  let Eid(e) = a
+  bytearray.from_int_big_endian(e, 4)
+}
+
+pub fn encode_nonce(a) -> ByteArray {
+  let Nonce(n) = a
+  bytearray.from_int_big_endian(n, 8)
+}
+
+pub fn encode_header_v1(h: types.PacketHeaderV1) -> ByteArray {
+  let b0 = bytearray.from_int_big_endian(1, 1)
+  let b1 = encode_nonce(h.nonce)
+  let b2 = encode_eid(h.src_eid)
+  let b3 = encode_address32(h.sender)
+  let b4 = encode_eid(h.dst_eid)
+  let b5 = encode_address20_to_bytes32(h.receiver_b20)
+  let b01 = bytearray.concat(b0, b1)
+  let b23 = bytearray.concat(b2, b3)
+  let b45 = bytearray.concat(b4, b5)
+  bytearray.concat(bytearray.concat(b01, b23), b45)
+}
+
+pub fn payload_hash(guid: types.Guid, message: ByteArray) -> ByteArray {
+  builtin.blake2b_256(bytearray.concat(unwrap_guid(guid), message))
+}
+
+pub fn header_version(header: ByteArray) -> ByteArray {
+  bytearray.slice(header, 0, 1)
+}
+
+pub fn header_nonce_be(header: ByteArray) -> ByteArray {
+  bytearray.slice(header, 1, 9)
+}
+
+pub fn header_src_eid_be(header: ByteArray) -> ByteArray {
+  bytearray.slice(header, 9, 13)
+}
+
+pub fn header_sender_b32(header: ByteArray) -> ByteArray {
+  bytearray.slice(header, 13, 45)
+}
+
+pub fn header_dst_eid_be(header: ByteArray) -> ByteArray {
+  bytearray.slice(header, 45, 49)
+}
+
+pub fn hash_header(header: ByteArray) -> ByteArray {
+  builtin.blake2b_256(header)
+}
+
+pub fn header_dst_eid(header: ByteArray) -> types.Eid {
+  let be = header_dst_eid_be(header)
+  types.Eid(bytearray.to_int_big_endian(be))
+}
+
+pub fn header_nonce(header: ByteArray) -> types.Nonce {
+  let be = header_nonce_be(header)
+  types.Nonce(bytearray.to_int_big_endian(be))
+}
+
+pub fn parse_header_v1(header: ByteArray) -> Option<types.PacketHeaderV1> {
+  if bytearray.length(header) != 81 {
+    None
+  } else {
+    let ver = header_version(header)
+    if ver == bytearray.from_int_big_endian(1, 1) {
+      let nonce = header_nonce(header)
+      let src_eid = types.Eid(bytearray.to_int_big_endian(header_src_eid_be(header)))
+      let sender_b32 = header_sender_b32(header)
+      let dst_eid = header_dst_eid(header)
+      let recv20 = header_receiver_b20(header)
+      Some(types.PacketHeaderV1 {
+        nonce: nonce,
+        src_eid: src_eid,
+        sender: types.Address32(sender_b32),
+        dst_eid: dst_eid,
+        receiver_b20: recv20,
+      })
+    } else {
+      None
+    }
+  }
+}
+
+
+
+fn unwrap_guid(g) -> ByteArray {
+  let Guid(b) = g
+  b
+}
+pub fn assert_header_v1(header: ByteArray, local_eid: types.Eid) -> Bool {
+  // length must be 81 bytes as per EVM PacketV1 header
+  if bytearray.length(header) != 81 {
+    False
+  } else {
+    let version = bytearray.slice(header, 0, 1)
+    let expected_version = bytearray.from_int_big_endian(1, 1)
+    let dst_eid_be = bytearray.slice(header, 45, 49)
+    let types.Eid(eid_int) = local_eid
+    let expected_dst_eid = bytearray.from_int_big_endian(eid_int, 4)
+    version == expected_version && dst_eid_be == expected_dst_eid
+  }
+}
+
+pub fn header_receiver_b20(header: ByteArray) -> types.Address20 {
+  // receiver is bytes32 at offset 49..81; take last 20 bytes
+  let receiver_b32 = bytearray.slice(header, 49, 81)
+  let b20 = bytearray.slice(receiver_b32, 12, 32)
+  types.Address20(b20)
+}

src/cardano/contracts/aiken/lib/layerzero/constants.ak

@@ -0,0 +1,2 @@
+pub const header_v1_version = 1
+pub const header_v1_len = 81

src/cardano/contracts/aiken/lib/layerzero/dvn_helpers.ak

@@ -0,0 +1,62 @@
+use aiken/collection/list
+use aiken/primitive/bytearray
+use aiken/builtin
+
+use layerzero/types
+
+pub fn quorum_satisfied(sc: Int, q: Int) -> Bool {
+  sc >= q && q > 0
+}
+
+pub fn attestation_message(hh: ByteArray, ph: ByteArray) -> ByteArray {
+  bytearray.concat(hh, ph)
+}
+
+pub fn unique_signers(pubs: List<types.Address32>) -> Bool {
+  let seen =
+    list.foldr(
+      pubs,
+      [],
+      fn(p, acc) {
+        let types.Address32(b) = p
+        if list.any(acc, fn(x) { x == b }) {
+          acc
+        } else {
+          [b, ..acc]
+        }
+      },
+    )
+  list.length(seen) == list.length(pubs)
+}
+
+pub fn signers_within_set(pubs: List<types.Address32>, set: List<types.Address32>) -> Bool {
+  pubs
+    |> list.all(fn(p) {
+      let types.Address32(b) = p
+      list.any(set, fn(s) {
+        let types.Address32(sb) = s
+        sb == b
+      })
+    })
+}
+
+pub fn verify_multisig(
+  message: ByteArray,
+  pubs: List<types.Address32>,
+  sigs: List<ByteArray>,
+  quorum: Int,
+) -> Bool {
+  let pairs = list.zip(pubs, sigs)
+  let valid = list.foldr(
+    pairs,
+    0,
+    fn(pair, acc) {
+      let p = pair.1st
+      let s = pair.2nd
+      let types.Address32(pk) = p
+      let ok = builtin.verify_ed25519_signature(pk, message, s)
+      acc + if ok { 1 } else { 0 }
+    },
+  )
+  valid >= quorum && quorum > 0
+}

src/cardano/contracts/aiken/lib/layerzero/endpoint_helpers.ak

@@ -0,0 +1,38 @@
+use layerzero/types
+
+pub fn nonce_next_ok(current: types.Nonce, incoming: types.Nonce) -> Bool {
+  let types.Nonce(c) = current
+  let types.Nonce(n) = incoming
+  n == c + 1
+}
+
+pub type ChannelState {
+  ChannelState {
+    lazy_inbound_nonce: types.Nonce,
+    executable: Bool,
+  }
+}
+
+pub fn mark_verifiable(s: ChannelState, incoming: types.Nonce) -> ChannelState {
+  if nonce_next_ok(s.lazy_inbound_nonce, incoming) {
+    ChannelState {
+      lazy_inbound_nonce: s.lazy_inbound_nonce,
+      executable: True,
+    }
+  } else {
+    s
+  }
+}
+
+pub fn consume_executable_and_advance(s: ChannelState, incoming: types.Nonce) -> ChannelState {
+  let types.Nonce(c) = s.lazy_inbound_nonce
+  let types.Nonce(n) = incoming
+  if s.executable == True && n == c + 1 {
+    ChannelState {
+      lazy_inbound_nonce: types.Nonce(n),
+      executable: False,
+    }
+  } else {
+    s
+  }
+}