diff --git a/CHANGELOG.md b/CHANGELOG.md
index fd837af..be3c76e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,15 @@
 # Changelog
 
+## v2.2.0 - UNRELEASED
+
+### Added
+
+- Transaction specific functionality:
+    - Assets / Value Fuzzers
+    - Certificate Fuzzers
+    - Credential and Address Fuzzers
+    - Transaction Fuzzer helpers
+
 ## v2.1.0 - 2024-09-24
 
 ### Added
diff --git a/aiken.toml b/aiken.toml
index d19db56..cb6ae36 100644
--- a/aiken.toml
+++ b/aiken.toml
@@ -1,6 +1,6 @@
 name = "aiken-lang/fuzz"
 version = "main"
-compiler = "v1.1.3"
+compiler = "v1.1.9"
 plutus = "v3"
 license = "Apache-2.0"
 description = "A library for writing Aiken's fuzzers."
diff --git a/lib/aiken/fuzz/scenario.ak b/lib/aiken/fuzz/scenario.ak
new file mode 100644
index 0000000..b50c0d5
--- /dev/null
+++ b/lib/aiken/fuzz/scenario.ak
@@ -0,0 +1,441 @@
+////  This Source Code Form is subject to the terms of the Mozilla Public
+////  License, v. 2.0. If a copy of the MPL was not distributed with this
+////  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+////  This is a modified distribution of https://github.com/CardanoSolutions/zhuli/blob/main/lib/aiken/fuzz/scenario.ak
+
+use aiken/cbor.{serialise}
+use aiken/collection/dict
+use aiken/collection/list
+use aiken/collection/pairs
+use aiken/crypto.{ScriptHash, blake2b_256}
+use aiken/fuzz.{and_then, byte, constant, map}
+use cardano/address.{Credential, Script}
+use cardano/assets.{PolicyId}
+use cardano/certificate.{
+  AuthorizeConstitutionalCommitteeProxy, Certificate, DelegateCredential,
+  RegisterAndDelegateCredential, RegisterDelegateRepresentative,
+  RetireFromConstitutionalCommittee, UnregisterCredential,
+  UnregisterDelegateRepresentative, UpdateDelegateRepresentative,
+}
+use cardano/governance.{
+  ConstitutionalCommitteeMember, DelegateRepresentative, Voter,
+}
+use cardano/script_context.{
+  Minting, Publishing, ScriptContext, Spending, Voting, Withdrawing,
+}
+use cardano/transaction.{
+  DatumHash, InlineDatum, Input, Mint, NoDatum, OutputReference, Publish, Spend,
+  Transaction, Vote, Withdraw,
+}
+
+const max_tries: Int = 50
+
+const max_byte: Int = 255
+
+pub type Label =
+  String
+
+pub type Scenario<st> {
+  Done
+  Scenario(List<Label>, st, Transaction)
+}
+
+// ## Constructing
+
+pub fn ok(
+  initial_state: st,
+  step: fn(st, List<Input>) -> Fuzzer<Scenario<st>>,
+) -> Fuzzer<List<Transaction>> {
+  map(gen_scenario_repeatedly(True, initial_state, step, 0), fn(x) { x.2nd })
+}
+
+pub fn ko(
+  initial_state: st,
+  step: fn(st, List<Input>) -> Fuzzer<Scenario<st>>,
+) -> Fuzzer<(List<Label>, List<Transaction>)> {
+  gen_scenario_repeatedly(False, initial_state, step, 0)
+}
+
+fn gen_scenario_repeatedly(
+  keep_ok: Bool,
+  initial_state: st,
+  step: fn(st, List<Input>) -> Fuzzer<Scenario<st>>,
+  n: Int,
+) -> Fuzzer<(List<Label>, List<Transaction>)> {
+  if n > max_tries {
+    if keep_ok {
+      fail @"fail to generate O.K. scenarios: too many K.O. ones"
+    } else {
+      fail @"fail to generate K.O. scenarios: too many O.K. ones"
+    }
+  } else {
+    let scenario <- and_then(gen_scenario([], initial_state, step))
+    when scenario is {
+      ([], []) -> constant(([], []))
+      ([], txs) ->
+        if keep_ok {
+          constant(([], txs))
+        } else {
+          gen_scenario_repeatedly(keep_ok, initial_state, step, n + 1)
+        }
+      (labels, txs) ->
+        if keep_ok {
+          gen_scenario_repeatedly(keep_ok, initial_state, step, n + 1)
+        } else {
+          constant((labels, txs))
+        }
+    }
+  }
+}
+
+fn gen_scenario(
+  utxo: List<Input>,
+  st: st,
+  step: fn(st, List<Input>) -> Fuzzer<Scenario<st>>,
+) -> Fuzzer<(List<Label>, List<Transaction>)> {
+  let next <- and_then(step(st, utxo))
+  when next is {
+    Done -> constant(([], []))
+    Scenario([], st_new, tx) -> {
+      let transaction_id = blake2b_256(serialise(tx))
+      let utxo =
+        list.indexed_foldr(
+          tx.outputs,
+          [],
+          fn(output_index, output, tail) {
+            [
+              Input {
+                output_reference: OutputReference {
+                  transaction_id,
+                  output_index,
+                },
+                output,
+              },
+              ..tail
+            ]
+          },
+        )
+      let (labels, txs) <- and_then(gen_scenario(utxo, st_new, step))
+      constant((labels, [tx, ..txs]))
+    }
+    Scenario(labels, _, tx) -> constant((labels, [tx]))
+  }
+}
+
+// ## Inspecting
+
+pub type Outcome {
+  Ok
+  Ko
+}
+
+/// A generator meant to analyze the scenario generator, to control that it is
+/// relatively well-balanced between O.K. and K.O. scenarios.
+pub fn report_coverage(
+  initial_state: st,
+  step: fn(st, List<Input>) -> Fuzzer<Scenario<st>>,
+) -> Fuzzer<Outcome> {
+  let scenario <- map(gen_scenario([], initial_state, step))
+  when scenario is {
+    ([], []) -> fail @"generated empty scenario?"
+    ([], _txs) -> Ok
+    (_labels, _txs) -> Ko
+  }
+}
+
+// ## Running
+
+/// Run a given scenario for a given set of handlers.
+pub fn run(
+  scenario: List<Transaction>,
+  script: ScriptHash,
+  mint: fn(Data, PolicyId, Transaction) -> Bool,
+  spend: fn(Option<Data>, Data, OutputReference, Transaction) -> Bool,
+  withdraw: fn(Data, Credential, Transaction) -> Bool,
+  publish: fn(Data, Certificate, Transaction) -> Bool,
+  vote: fn(Data, Voter, Transaction) -> Bool,
+) {
+  when scenario is {
+    [] -> Void
+    [next, ..tail] -> {
+      expect mint_handlers(next, script, mint)
+      expect spend_handlers(next, script, spend)
+      expect withdraw_handlers(next, script, withdraw)
+      expect publish_handlers(next, script, publish)
+      expect vote_handlers(next, script, vote)
+      run(tail, script, mint, spend, withdraw, publish, vote)
+    }
+  }
+}
+
+pub fn else_to_mint(
+  mint: fn(ScriptContext) -> Bool,
+) -> fn(Data, PolicyId, Transaction) -> Bool {
+  fn(r: Data, p: PolicyId, t: Transaction) -> Bool {
+    mint(ScriptContext(t, r, Minting(p)))
+  }
+}
+
+fn mint_handlers(
+  self: Transaction,
+  script: ScriptHash,
+  mint: fn(Data, PolicyId, Transaction) -> Bool,
+) -> Bool {
+  list.foldr(
+    assets.policies(self.mint),
+    True,
+    fn(policy_id, st) {
+      if policy_id == script {
+        and {
+          st,
+          {
+            expect Some(redeemer) =
+              pairs.get_first(self.redeemers, Mint(policy_id))
+            mint(redeemer, policy_id, self)
+          },
+        }
+      } else {
+        st
+      }
+    },
+  )
+}
+
+pub fn else_to_spend(spend: fn(ScriptContext) -> Bool) {
+  fn(d: Option<Data>, r: Data, o_ref: OutputReference, t: Transaction) -> Bool {
+    spend(ScriptContext(t, r, Spending(o_ref, d)))
+  }
+}
+
+fn spend_handlers(
+  self: Transaction,
+  script: ScriptHash,
+  spend: fn(Option<Data>, Data, OutputReference, Transaction) -> Bool,
+) -> Bool {
+  list.foldr(
+    self.inputs,
+    True,
+    fn(input, st) {
+      if input.output.address.payment_credential == Script(script) {
+        and {
+          st,
+          {
+            expect Some(redeemer) =
+              pairs.get_first(self.redeemers, Spend(input.output_reference))
+            let datum =
+              when input.output.datum is {
+                NoDatum -> None
+                DatumHash(digest) -> dict.get(self.datums, digest)
+                InlineDatum(datum) -> Some(datum)
+              }
+            spend(datum, redeemer, input.output_reference, self)
+          },
+        }
+      } else {
+        st
+      }
+    },
+  )
+}
+
+pub fn else_to_withdraw(withdraw: fn(ScriptContext) -> Bool) {
+  fn(r: Data, cred: Credential, t: Transaction) -> Bool {
+    withdraw(ScriptContext(t, r, Withdrawing(cred)))
+  }
+}
+
+fn withdraw_handlers(
+  self: Transaction,
+  script: ScriptHash,
+  withdraw: fn(Data, Credential, Transaction) -> Bool,
+) -> Bool {
+  pairs.foldr(
+    self.withdrawals,
+    True,
+    fn(account, _amount, st) {
+      if account == Script(script) {
+        and {
+          st,
+          {
+            expect Some(redeemer) =
+              pairs.get_first(self.redeemers, Withdraw(account))
+            withdraw(redeemer, account, self)
+          },
+        }
+      } else {
+        st
+      }
+    },
+  )
+}
+
+pub fn else_to_publish(publish: fn(ScriptContext) -> Bool) {
+  fn(r: Data, c: Certificate, t: Transaction) -> Bool {
+    expect Some(ix) = list.index_of(t.certificates, c)
+    publish(ScriptContext(t, r, Publishing(ix, c)))
+  }
+}
+
+fn publish_handlers(
+  self: Transaction,
+  script: ScriptHash,
+  publish: fn(Data, Certificate, Transaction) -> Bool,
+) -> Bool {
+  list.indexed_foldr(
+    self.certificates,
+    True,
+    fn(ix, certificate, st) {
+      when certificate is {
+        UnregisterCredential { credential, .. } |
+        DelegateCredential { credential, .. } |
+        RegisterAndDelegateCredential { credential, .. } |
+        RegisterDelegateRepresentative {
+          delegate_representative: credential,
+          ..
+        } |
+        UpdateDelegateRepresentative { delegate_representative: credential } |
+        UnregisterDelegateRepresentative {
+          delegate_representative: credential,
+          ..
+        } |
+        AuthorizeConstitutionalCommitteeProxy {
+          constitutional_committee_member: credential,
+          ..
+        } |
+        RetireFromConstitutionalCommittee {
+          constitutional_committee_member: credential,
+        } ->
+          if credential == Script(script) {
+            and {
+              st,
+              {
+                expect Some(redeemer) =
+                  pairs.get_first(self.redeemers, Publish(ix, certificate))
+                publish(redeemer, certificate, self)
+              },
+            }
+          } else {
+            st
+          }
+
+        _ -> st
+      }
+    },
+  )
+}
+
+pub fn else_to_vote(vote: fn(ScriptContext) -> Bool) {
+  fn(r: Data, v: Voter, t: Transaction) -> Bool {
+    vote(ScriptContext(t, r, Voting(v)))
+  }
+}
+
+fn vote_handlers(
+  self: Transaction,
+  script: ScriptHash,
+  vote: fn(Data, Voter, Transaction) -> Bool,
+) -> Bool {
+  pairs.foldr(
+    self.votes,
+    True,
+    fn(voter, _vote, st) {
+      let relevant = or {
+          voter == DelegateRepresentative(Script(script)),
+          voter == ConstitutionalCommitteeMember(Script(script)),
+        }
+
+      if relevant {
+        and {
+          st,
+          {
+            expect Some(redeemer) = pairs.get_first(self.redeemers, Vote(voter))
+            vote(redeemer, voter, self)
+          },
+        }
+      } else {
+        st
+      }
+    },
+  )
+}
+
+// ## Fuzzing
+
+/// The 'pivot' represents a value between 0 and 255 which represents the
+/// probability of NOT forking the main scenario on a branch. It needs to be
+/// high enough to have a high probability chance of generating valid scenarios
+/// despite many forks, but small enough that forks still occur.
+///
+/// Ideally, one wants `((255 - pivot) / 255)^num_forks ~ 0.5`
+pub fn fork(
+  pivot: Int,
+  main: fn() -> Fuzzer<a>,
+  branch: fn() -> Fuzzer<a>,
+) -> Fuzzer<a> {
+  let toss <- and_then(byte())
+  if toss < pivot {
+    main()
+  } else {
+    branch()
+  }
+}
+
+pub fn fork2(
+  pivot: Int,
+  main: fn() -> Fuzzer<a>,
+  branch1: fn() -> Fuzzer<a>,
+  branch2: fn() -> Fuzzer<a>,
+) -> Fuzzer<a> {
+  let toss <- and_then(byte())
+  let step = ( max_byte - pivot ) / 2
+  if toss < pivot {
+    main()
+  } else if toss < pivot + step {
+    branch1()
+  } else {
+    branch2()
+  }
+}
+
+pub fn fork3(
+  pivot: Int,
+  main: fn() -> Fuzzer<a>,
+  branch1: fn() -> Fuzzer<a>,
+  branch2: fn() -> Fuzzer<a>,
+  branch3: fn() -> Fuzzer<a>,
+) -> Fuzzer<a> {
+  let toss <- and_then(byte())
+  let step = ( max_byte - pivot ) / 3
+  if toss < pivot {
+    main()
+  } else if toss < pivot + step {
+    branch1()
+  } else if toss < pivot + 2 * step {
+    branch2()
+  } else {
+    branch3()
+  }
+}
+
+pub fn fork4(
+  pivot: Int,
+  main: Fuzzer<a>,
+  branch1: Fuzzer<a>,
+  branch2: Fuzzer<a>,
+  branch3: Fuzzer<a>,
+  branch4: Fuzzer<a>,
+) -> Fuzzer<a> {
+  let toss <- and_then(byte())
+  let step = ( max_byte - pivot ) / 4
+  if toss < pivot {
+    main
+  } else if toss < pivot + step {
+    branch1
+  } else if toss < pivot + 2 * step {
+    branch2
+  } else if toss < pivot + 3 * step {
+    branch3
+  } else {
+    branch4
+  }
+}
diff --git a/lib/cardano/fuzz.ak b/lib/cardano/fuzz.ak
new file mode 100644
index 0000000..6ea5943
--- /dev/null
+++ b/lib/cardano/fuzz.ak
@@ -0,0 +1,339 @@
+use aiken/collection/list
+use aiken/crypto.{ScriptHash}
+use aiken/fuzz.{
+  and_then, bool, bytearray_between, constant, int, int_at_least, int_between,
+  list_between, map, map2, map3, option,
+}
+use cardano/address.{Address, Credential, Inline, Script, VerificationKey}
+use cardano/address/credential
+use cardano/assets.{AssetName, Lovelace, PolicyId, Value}
+use cardano/certificate.{
+  AlwaysAbstain, AlwaysNoConfidence, AuthorizeConstitutionalCommitteeProxy,
+  Certificate, Delegate, DelegateBlockProduction, DelegateBoth,
+  DelegateCredential, DelegateRepresentative, DelegateVote,
+  RegisterAndDelegateCredential, RegisterCredential,
+  RegisterDelegateRepresentative, RegisterStakePool, Registered,
+  RetireFromConstitutionalCommittee, RetireStakePool, StakePoolId,
+  UnregisterCredential, UnregisterDelegateRepresentative,
+  UpdateDelegateRepresentative,
+}
+use cardano/transaction.{
+  Datum, DatumHash, InlineDatum, Input, NoDatum, Output, OutputReference,
+}
+
+// ## Address
+
+/// Generate an arbitrary `Credential`
+pub fn credential() -> Fuzzer<Credential> {
+  map2(
+    bool(),
+    bytearray_between(28, 28),
+    fn(coin_flip, key_hash) {
+      if coin_flip {
+        VerificationKey(key_hash)
+      } else {
+        Script(key_hash)
+      }
+    },
+  )
+}
+
+/// Generate an arbitrary `Address` (other than pointer addresses).
+pub fn address() -> Fuzzer<Address> {
+  let address_type <- and_then(int_between(0, 5))
+  when address_type is {
+    0 -> {
+      let payment <- map(bytearray_between(28, 28))
+      Address {
+        payment_credential: VerificationKey(payment),
+        stake_credential: None,
+      }
+    }
+    1 -> {
+      let payment <- map(bytearray_between(28, 28))
+      Address { payment_credential: Script(payment), stake_credential: None }
+    }
+    2 -> {
+      let payment <- and_then(bytearray_between(28, 28))
+      let stake <- map(bytearray_between(28, 28))
+      Address {
+        payment_credential: VerificationKey(payment),
+        stake_credential: Some(Inline(VerificationKey(stake))),
+      }
+    }
+    3 -> {
+      let payment <- and_then(bytearray_between(28, 28))
+      let stake <- map(bytearray_between(28, 28))
+      Address {
+        payment_credential: VerificationKey(payment),
+        stake_credential: Some(Inline(Script(stake))),
+      }
+    }
+    4 -> {
+      let payment <- and_then(bytearray_between(28, 28))
+      let stake <- map(bytearray_between(28, 28))
+      Address {
+        payment_credential: Script(payment),
+        stake_credential: Some(Inline(VerificationKey(stake))),
+      }
+    }
+    5 -> {
+      let payment <- and_then(bytearray_between(28, 28))
+      let stake <- map(bytearray_between(28, 28))
+      Address {
+        payment_credential: Script(payment),
+        stake_credential: Some(Inline(Script(stake))),
+      }
+    }
+    _ -> fail @"unexpected address type"
+  }
+}
+
+// ## Assets
+
+/// Generate an arbitrary asset name, between 0 and 32 bytes length.
+pub fn asset_name() -> Fuzzer<AssetName> {
+  bytearray_between(0, 32)
+}
+
+/// Generate assets from a given policy, adding them to the provided value accumulator
+pub fn assets(self: Value, policy_id: PolicyId) -> Fuzzer<Value> {
+  let names <- and_then(list_between(asset_name(), 1, 3))
+  list.foldr(
+    names,
+    constant(self),
+    fn(asset_name, step) {
+      let value <- and_then(step)
+      let quantity <- map(int_at_least(1))
+      value |> assets.add(policy_id, asset_name, quantity)
+    },
+  )
+}
+
+/// Generate a `Value` holding a **positive** quantity of lovelace, but no assets.
+pub fn lovelace() -> Fuzzer<Value> {
+  map(int_at_least(1000000), assets.from_lovelace)
+}
+
+/// Generate an arbitrary policy is (a.k.a script hash).
+pub fn policy_id() -> Fuzzer<PolicyId> {
+  bytearray_between(28, 28)
+}
+
+/// Generate an arbitrary `Value`, extending an existing one. Use
+/// `assets.zero` or `cardano.lovelace()` as a simple starting point.
+pub fn value(self: Value) -> Fuzzer<Value> {
+  let policies <- and_then(list_between(policy_id(), 0, 2))
+  list.foldr(
+    policies,
+    constant(self),
+    fn(policy_id, step) {
+      let value <- and_then(step)
+      assets(value, policy_id)
+    },
+  )
+}
+
+/// Extend an existing value using the given fuzzers for fine-grained control.
+///
+/// ```ak
+/// let value <- fuzz.value_with(
+///   value.zero,
+///   with_policies: fuzz.constant([my_policy_1, my_policy_2]),
+///   with_asset_name: fn(policy) {
+///     if policy == my_policy_1 {
+///        fuzz.one_of([asset_1, asset_2, asset_3])
+///     } else {
+///        fuzz.constant(my_other_asset)
+///     }
+///   },
+///   with_quantity: fn(_) { fuzz.constant(1) }
+/// )
+/// ```
+pub fn value_with(
+  self: Value,
+  with_policies: Fuzzer<List<PolicyId>>,
+  with_asset_name: fn(PolicyId) -> Fuzzer<AssetName>,
+  with_quantity: fn(AssetName) -> Fuzzer<Int>,
+) -> Fuzzer<Value> {
+  let policies <- and_then(with_policies)
+  list.foldr(
+    policies,
+    constant(self),
+    fn(policy, step) {
+      let value <- and_then(step)
+      let asset_name <- and_then(with_asset_name(policy))
+      let quantity <- map(with_quantity(asset_name))
+      value |> assets.add(policy, asset_name, quantity)
+    },
+  )
+}
+
+// ## Certificates
+
+pub fn certificate() -> Fuzzer<Certificate> {
+  let choice <- and_then(int_between(0, 10))
+  when choice is {
+    0 -> register_credential()
+    1 -> unregister_credential()
+    2 -> delegate_credential()
+    3 -> register_and_delegate_credential()
+    4 -> register_delegate_representative()
+    5 -> update_delegate_representative()
+    6 -> unregister_delegate_representative()
+    7 -> register_stake_pool()
+    8 -> retire_stake_pool()
+    9 -> authorize_constitutional_committee_proxy()
+    10 -> retire_from_constitutional_committee()
+    _ -> fail @"Fail"
+  }
+}
+
+pub fn delegate() -> Fuzzer<Delegate> {
+  let choice <- and_then(int_between(0, 2))
+  when choice is {
+    0 -> map(stake_pool_id(), DelegateBlockProduction)
+    1 -> map(delegate_representative(), DelegateVote)
+    2 -> map2(stake_pool_id(), delegate_representative(), DelegateBoth)
+    _ -> fail
+  }
+}
+
+pub fn delegate_representative() -> Fuzzer<DelegateRepresentative> {
+  let choice <- and_then(int_between(0, 2))
+  when choice is {
+    0 -> map(credential(), Registered)
+    1 -> constant(AlwaysAbstain)
+    2 -> constant(AlwaysNoConfidence)
+    _ -> fail
+  }
+}
+
+pub fn stake_pool_id() -> Fuzzer<StakePoolId> {
+  bytearray_between(32, 32)
+}
+
+// ### Fine-grained
+
+pub fn register_credential() -> Fuzzer<Certificate> {
+  map(credential(), fn(credential) { RegisterCredential(credential, Never) })
+}
+
+pub fn unregister_credential() -> Fuzzer<Certificate> {
+  map(credential(), fn(credential) { UnregisterCredential(credential, Never) })
+}
+
+pub fn delegate_credential() -> Fuzzer<Certificate> {
+  map2(credential(), delegate(), DelegateCredential)
+}
+
+pub fn register_and_delegate_credential() -> Fuzzer<Certificate> {
+  map3(credential(), delegate(), int(), RegisterAndDelegateCredential)
+}
+
+pub fn register_delegate_representative() -> Fuzzer<Certificate> {
+  map2(credential(), int(), RegisterDelegateRepresentative)
+}
+
+pub fn update_delegate_representative() -> Fuzzer<Certificate> {
+  map(credential(), UpdateDelegateRepresentative)
+}
+
+pub fn unregister_delegate_representative() -> Fuzzer<Certificate> {
+  map2(credential(), int(), UnregisterDelegateRepresentative)
+}
+
+pub fn register_stake_pool() -> Fuzzer<Certificate> {
+  map2(stake_pool_id(), bytearray_between(32, 32), RegisterStakePool)
+}
+
+pub fn retire_stake_pool() -> Fuzzer<Certificate> {
+  map2(stake_pool_id(), int(), RetireStakePool)
+}
+
+pub fn authorize_constitutional_committee_proxy() -> Fuzzer<Certificate> {
+  map2(credential(), credential(), AuthorizeConstitutionalCommitteeProxy)
+}
+
+pub fn retire_from_constitutional_committee() -> Fuzzer<Certificate> {
+  map(credential(), RetireFromConstitutionalCommittee)
+}
+
+// ## Transaction
+
+pub fn datum() -> Fuzzer<Datum> {
+  let variant <- and_then(int_between(0, 2))
+  when variant is {
+    0 -> constant(NoDatum)
+    1 -> {
+      let hash <- map(bytearray_between(32, 32))
+      DatumHash(hash)
+    }
+    2 -> {
+      let i <- map(int())
+      InlineDatum(i)
+    }
+    _ -> fail @"unexpected datum variant"
+  }
+}
+
+pub fn output() -> Fuzzer<Output> {
+  let address <- and_then(address())
+  let value <- and_then(and_then(lovelace(), value))
+  let datum <- and_then(datum())
+  let reference_script <- map(reference_script())
+  Output { address, value, datum, reference_script }
+}
+
+pub fn reference_script() -> Fuzzer<Option<ScriptHash>> {
+  option(bytearray_between(28, 28))
+}
+
+pub fn output_reference() -> Fuzzer<OutputReference> {
+  let transaction_id <- and_then(bytearray_between(32, 32))
+  let output_index <- map(int_between(0, 300))
+  OutputReference { transaction_id, output_index }
+}
+
+pub fn input() -> Fuzzer<Input> {
+  let output_reference <- and_then(output_reference())
+  let output <- map(output())
+  Input { output_reference, output }
+}
+
+/// Generate Withdrawals
+pub fn withdrawals() -> Fuzzer<Pairs<Credential, Lovelace>> {
+  map(
+    list_between(
+      map2(
+        credential(),
+        int_between(0, 200000000000),
+        fn(c, i) {
+          let l: Lovelace = i
+          Pair(c, l)
+        },
+      ),
+      0,
+      5,
+    ),
+    fn(l) {
+      let ps: Pairs<Credential, Lovelace> =
+        list.sort(l, fn(e1, e2) { credential.compare(e1.1st, e2.1st) })
+      ps
+    },
+  )
+}
+
+pub fn withdrawals_extending(
+  with: Pairs<Credential, Lovelace>,
+) -> Fuzzer<Pairs<Credential, Lovelace>> {
+  map(
+    withdrawals(),
+    fn(w) {
+      list.sort(
+        list.concat(w, with),
+        fn(e1, e2) { credential.compare(e1.1st, e2.1st) },
+      )
+    },
+  )
+}
diff --git a/lib/cardano/fuzz/address.test.ak b/lib/cardano/fuzz/address.test.ak
new file mode 100644
index 0000000..6b75d9d
--- /dev/null
+++ b/lib/cardano/fuzz/address.test.ak
@@ -0,0 +1,40 @@
+use aiken/fuzz.{label}
+use cardano/address.{Address, Inline, Script, VerificationKey}
+use cardano/fuzz as cardano
+
+test prop_credential(credential via cardano.credential()) {
+  label(
+    when credential is {
+      Script(_) -> @"Script"
+      VerificationKey(_) -> @"VerificationKey"
+    },
+  )
+}
+
+test prop_address(a via cardano.address()) {
+  label(
+    when a is {
+      Address { payment_credential: VerificationKey(_), stake_credential: None } ->
+        @"VerificationKey_NoStake"
+      Address { payment_credential: Script(_), stake_credential: None } ->
+        @"Script_NoStake"
+      Address {
+        payment_credential: VerificationKey(_),
+        stake_credential: Some(Inline(VerificationKey(_))),
+      } -> @"VerificationKey_InlineVerificationKey"
+      Address {
+        payment_credential: VerificationKey(_),
+        stake_credential: Some(Inline(Script(_))),
+      } -> @"VerificationKey_InlineScript"
+      Address {
+        payment_credential: Script(_),
+        stake_credential: Some(Inline(VerificationKey(_))),
+      } -> @"Script_InlineVerificationKey"
+      Address {
+        payment_credential: Script(_),
+        stake_credential: Some(Inline(Script(_))),
+      } -> @"Script_InlineScript"
+      _ -> fail @"Unexpected Address from address"
+    },
+  )
+}
diff --git a/lib/cardano/fuzz/assets.test.ak b/lib/cardano/fuzz/assets.test.ak
new file mode 100644
index 0000000..64d489f
--- /dev/null
+++ b/lib/cardano/fuzz/assets.test.ak
@@ -0,0 +1,30 @@
+use aiken/collection/dict
+use aiken/fuzz
+use cardano/assets.{PolicyId, Value}
+use cardano/fuzz as cardano
+
+fn help_prop_value_with() -> Fuzzer<(PolicyId, Value)> {
+  let policy <- fuzz.and_then(cardano.policy_id())
+  let value <- fuzz.map(cardano.assets(assets.from_lovelace(1000000), policy))
+  (policy, value)
+}
+
+test prop_value_with((policy, value) via help_prop_value_with()) {
+  assets.tokens(value, policy) != dict.empty
+}
+
+fn help_prop_value() -> Fuzzer<(Value, Value)> {
+  let initial <- fuzz.and_then(cardano.lovelace())
+  let extended <- fuzz.map(cardano.value(initial))
+  (initial, extended)
+}
+
+test prop_value((initial, extended) via help_prop_value()) {
+  assets.reduce(
+    extended,
+    True,
+    fn(policy_id, asset_name, quantity, is_larger) {
+      is_larger && assets.quantity_of(initial, policy_id, asset_name) <= quantity
+    },
+  )
+}
diff --git a/lib/cardano/fuzz/certificate.test.ak b/lib/cardano/fuzz/certificate.test.ak
new file mode 100644
index 0000000..84cdb2a
--- /dev/null
+++ b/lib/cardano/fuzz/certificate.test.ak
@@ -0,0 +1,53 @@
+use aiken/fuzz.{label}
+use cardano/certificate.{
+  AlwaysAbstain, AlwaysNoConfidence, AuthorizeConstitutionalCommitteeProxy,
+  DelegateBlockProduction, DelegateBoth, DelegateCredential, DelegateVote,
+  RegisterAndDelegateCredential, RegisterCredential,
+  RegisterDelegateRepresentative, RegisterStakePool, Registered,
+  RetireFromConstitutionalCommittee, RetireStakePool, UnregisterCredential,
+  UnregisterDelegateRepresentative, UpdateDelegateRepresentative,
+}
+use cardano/fuzz.{delegate, delegate_representative} as fuzz_cert
+
+test prop_certificate(c via fuzz_cert.certificate()) {
+  label(
+    when c is {
+      RegisterCredential(_, _) -> @"RegisterCredential"
+      UnregisterCredential(_, _) -> @"UnregisterCredential"
+      DelegateCredential(_, _) -> @"DelegateCredential"
+      RegisterAndDelegateCredential(_, _, _) -> @"RegisterAndDelegateCredential"
+      RegisterDelegateRepresentative(_, _) -> @"RegisterDelegateRepresentative"
+      UpdateDelegateRepresentative(_) -> @"UpdateDelegateRepresentative"
+      UnregisterDelegateRepresentative(_, _) ->
+        @"UnregisterDelegateRepresentative"
+      RegisterStakePool(_, _) -> @"RegisterStakePool"
+      RetireStakePool(_, _) -> @"RetireStakePool"
+      AuthorizeConstitutionalCommitteeProxy(_, _) ->
+        @"AuthorizeConstitutionalCommitteeProxy"
+      RetireFromConstitutionalCommittee(_) ->
+        @"RetireFromConstitutionalCommittee"
+    },
+  )
+}
+
+/// Test for delegate generator
+test prop_delegate(d via delegate()) {
+  label(
+    when d is {
+      DelegateBlockProduction(_) -> @"DelegateBlockProduction"
+      DelegateVote(_) -> @"DelegateVote"
+      DelegateBoth(_, _) -> @"DelegateBoth"
+    },
+  )
+}
+
+/// Test for delegate_representative (DelegateRepresentative) generator
+test prop_delegate_representative(d via delegate_representative()) {
+  label(
+    when d is {
+      Registered(_) -> @"Registered"
+      AlwaysAbstain -> @"AlwaysAbstain"
+      AlwaysNoConfidence -> @"AlwaysNoConfidence"
+    },
+  )
+}
diff --git a/lib/cardano/fuzz/transaction.ak b/lib/cardano/fuzz/transaction.ak
new file mode 100644
index 0000000..31de4d7
--- /dev/null
+++ b/lib/cardano/fuzz/transaction.ak
@@ -0,0 +1,228 @@
+use aiken/collection/list
+use aiken/crypto.{VerificationKeyHash}
+use aiken/fuzz.{map, map7}
+use cardano/address.{Credential}
+use cardano/assets.{Lovelace, Value, ada_asset_name, ada_policy_id}
+use cardano/certificate.{Certificate}
+use cardano/fuzz as cardano
+use cardano/transaction.{Input, Output, Redeemer, ScriptPurpose, Transaction}
+
+// > [!IMPORTANT]
+// The following fields on the transaction are not handled within our library.
+// datums: Dict<DataHash, Data>,
+// id: TransactionId,
+// votes: Pairs<Voter, Pairs<GovernanceActionId, Vote>>,
+// proposal_procedures: List<ProposalProcedure>,
+// current_treasury_amount: Option<Lovelace>,
+// treasury_donation: Option<Lovelace>,
+
+// Transaction stuffz
+
+pub fn add_fuzz_input(
+  self: Transaction,
+  input: Fuzzer<Input>,
+) -> Fuzzer<Transaction> {
+  map(
+    input,
+    fn(in) { Transaction { ..self, inputs: [in, ..self.reference_inputs] } },
+  )
+}
+
+pub fn add_fuzz_inputs(
+  self: Transaction,
+  ins: Fuzzer<List<Input>>,
+) -> Fuzzer<Transaction> {
+  map(
+    ins,
+    fn(ins) { Transaction { ..self, inputs: list.concat(ins, self.inputs) } },
+  )
+}
+
+pub fn add_fuzz_ref_input(
+  self: Transaction,
+  input: Fuzzer<Input>,
+) -> Fuzzer<Transaction> {
+  map(
+    input,
+    fn(in) {
+      Transaction { ..self, reference_inputs: [in, ..self.reference_inputs] }
+    },
+  )
+}
+
+pub fn add_fuzz_ref_inputs(
+  self: Transaction,
+  inputs: Fuzzer<List<Input>>,
+) -> Fuzzer<Transaction> {
+  map(
+    inputs,
+    fn(ins) {
+      Transaction {
+        ..self,
+        reference_inputs: list.concat(ins, self.reference_inputs),
+      }
+    },
+  )
+}
+
+pub fn add_fuzz_output(
+  self: Transaction,
+  output: Fuzzer<Output>,
+) -> Fuzzer<Transaction> {
+  map(
+    output,
+    fn(out) { Transaction { ..self, outputs: [out, ..self.outputs] } },
+  )
+}
+
+pub fn add_fuzz_outputs(
+  self: Transaction,
+  outs: Fuzzer<List<Output>>,
+) -> Fuzzer<Transaction> {
+  map(
+    outs,
+    fn(os) { Transaction { ..self, outputs: list.concat(os, self.outputs) } },
+  )
+}
+
+pub fn add_fuzz_mint(
+  self: Transaction,
+  mint: Fuzzer<Value>,
+) -> Fuzzer<Transaction> {
+  map(mint, fn(m) { Transaction { ..self, mint: m } })
+}
+
+pub fn add_fuzz_cert(
+  self: Transaction,
+  cert: Fuzzer<Certificate>,
+) -> Fuzzer<Transaction> {
+  map(
+    cert,
+    fn(c) { Transaction { ..self, certificates: [c, ..self.certificates] } },
+  )
+}
+
+pub fn add_fuzz_withdrawals(
+  self: Transaction,
+  withdraws: Fuzzer<Pairs<Credential, Lovelace>>,
+) -> Fuzzer<Transaction> {
+  map(
+    withdraws,
+    fn(w) {
+      Transaction { ..self, withdrawals: list.concat(w, self.withdrawals) }
+    },
+  )
+}
+
+pub fn add_fuzz_signers(
+  self: Transaction,
+  signers: Fuzzer<List<VerificationKeyHash>>,
+) -> Fuzzer<Transaction> {
+  map(
+    signers,
+    fn(s) {
+      Transaction {
+        ..self,
+        extra_signatories: list.concat(s, self.extra_signatories),
+      }
+    },
+  )
+}
+
+pub fn add_fuzz_redeemers(
+  self: Transaction,
+  redeemers: Fuzzer<Pairs<ScriptPurpose, Redeemer>>,
+) -> Fuzzer<Transaction> {
+  map(
+    redeemers,
+    fn(r) { Transaction { ..self, redeemers: list.concat(r, self.redeemers) } },
+  )
+}
+
+pub fn generic_tx() -> Fuzzer<Transaction> {
+  let tx <-
+    fuzz.and_then(
+      add_fuzz_inputs(transaction.placeholder, fuzz.list(cardano.input())),
+    )
+  add_fuzz_outputs(tx, fuzz.list(cardano.output()))
+}
+
+// TODO - Rewrite this handling separate parts of the tx separately.
+// We also need to add test(s) for this.
+/// > [!IMPORTANT]
+/// This function does not consider certificates.
+/// It only pays attention to withdrawals, inputs,
+///  outputs, and the current fee.
+pub fn balance_tx(self: Transaction) -> Fuzzer<Transaction> {
+  let Transaction { inputs, withdrawals, outputs, fee, .. } = self
+  let input_total =
+    list.foldr(
+      inputs,
+      assets.zero,
+      fn(in, v) { assets.merge(in.output.value, v) },
+    )
+  let withdrawals_total =
+    list.foldr(
+      withdrawals,
+      0,
+      fn(p, acc) {
+        let Pair(_, i) = p
+        acc + i
+      },
+    )
+  let total_in =
+    assets.add(
+      input_total,
+      ada_policy_id,
+      ada_asset_name,
+      fee + withdrawals_total,
+    )
+  let output_total =
+    list.foldr(outputs, assets.zero, fn(out, v) { assets.merge(out.value, v) })
+  let added_input_value =
+    assets.reduce(
+      output_total,
+      assets.zero,
+      fn(p, a, i, r) {
+        let res = i - assets.quantity_of(total_in, p, a)
+        if res > 0 {
+          assets.add(r, p, a, res)
+        } else {
+          r
+        }
+      },
+    )
+      |> assets.add(ada_policy_id, ada_asset_name, 1)
+  let added_output_value =
+    assets.reduce(
+      total_in,
+      assets.zero,
+      fn(p, a, i, r) {
+        let res = i - assets.quantity_of(output_total, p, a)
+        if res > 0 {
+          assets.add(r, p, a, res)
+        } else {
+          r
+        }
+      },
+    )
+      |> assets.add(ada_policy_id, ada_asset_name, 1)
+  map7(
+    cardano.output_reference(),
+    cardano.address(),
+    cardano.address(),
+    cardano.datum(),
+    cardano.datum(),
+    cardano.reference_script(),
+    cardano.reference_script(),
+    fn(o_ref, a1, a2, d1, d2, r1, r2) {
+      let new_input = Input(o_ref, Output(a1, added_input_value, d1, r1))
+      let new_output = Output(a2, added_output_value, d2, r2)
+      Transaction {
+        ..self,
+        inputs: [new_input, ..self.inputs],
+        outputs: [new_output, ..self.outputs],
+      }
+    },
+  )
+}