diff --git a/aiken.toml b/aiken.toml
index 7a116ba..8135907 100644
--- a/aiken.toml
+++ b/aiken.toml
@@ -21,4 +21,4 @@ version = "2.2.0"
 source = "github"
 
 [config.default]
-now = 1768998897000
+now = 1769000103000
diff --git a/docs/config.html b/docs/config.html
index 7406186..105f03a 100644
--- a/docs/config.html
+++ b/docs/config.html
@@ -305,7 +305,7 @@ <h1 id="module-constants" class="module-member-kind">
   
   <div class="member">
     <div class="member-name">
-      <h2 id="now"><pre class="hljs language-aiken">now: Int = 1768998897000</pre></h2>
+      <h2 id="now"><pre class="hljs language-aiken">now: Int = 1769000103000</pre></h2>
       
         <a class="member-source" alt="view source" title="view source" target="_blank" href="https://github.com/aiken-extra/test_kit/blob/lithium-β/#L1"></a>
       
@@ -437,9 +437,9 @@ <h2 id="now"><pre class="hljs language-aiken">now: Int = 1768998897000</pre></h2
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="./js/lunr.min.js?v=1.1.21"></script>
-    <script src="./js/index.js?v=1768998915"></script>
+    <script src="./js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="./search-data.js?v=1768998915"></script>
+    <script src="./search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/index.html b/docs/index.html
index a81328f..0f62515 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -289,9 +289,9 @@ <h1>test_kit</h1>
 <tr><td>🟡</td><td><strong>Version</strong></td><td><strong>v0.1.0</strong></td><td>🛠️</td></tr>
 <tr><td>🟡</td><td><strong>Codename</strong></td><td><strong>lithium</strong></td><td>☄️</td></tr>
 <tr><td>🟡</td><td><strong>Status</strong></td><td><strong>beta</strong></td><td>⚗️</td></tr>
-<tr><td>🟢</td><td><strong>Depends on</strong></td><td><a href="https://github.com/aiken-lang/fuzz/releases/tag/v2.1.0"><strong>aiken-lang/fuzz v2.2.0</strong></a></td><td>✅</td></tr>
-<tr><td>🟢</td><td><strong>Depends on</strong></td><td><a href="https://github.com/aiken-lang/stdlib/releases/tag/v2.2.0"><strong>aiken-lang/stdlib v3.0.0</strong></a></td><td>✅</td></tr>
-<tr><td>🟢</td><td><strong>Tested with</strong></td><td><a href="https://github.com/aiken-lang/aiken/releases/tag/v1.1.9"><strong>aiken v1.1.21</strong></a></td><td>✅</td></tr>
+<tr><td>🟢</td><td><strong>Depends on</strong></td><td><a href="https://github.com/aiken-lang/fuzz/releases/tag/v2.2.0"><strong>aiken-lang/fuzz v2.2.0</strong></a></td><td>✅</td></tr>
+<tr><td>🟢</td><td><strong>Depends on</strong></td><td><a href="https://github.com/aiken-lang/stdlib/releases/tag/v3.0.0"><strong>aiken-lang/stdlib v3.0.0</strong></a></td><td>✅</td></tr>
+<tr><td>🟢</td><td><strong>Tested with</strong></td><td><a href="https://github.com/aiken-lang/aiken/releases/tag/v1.1.21"><strong>aiken v1.1.21</strong></a></td><td>✅</td></tr>
 </tbody></table>
 <!-- | 🟢  | **Version**     | **boron**                                                                                | ✅  | -->
 <!-- | 🟡  | **Version**     | **v0.1.1**                                                                               | 🛠️  | -->
@@ -528,9 +528,9 @@ <h2><code>tx</code></h2>
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="./js/lunr.min.js?v=1.1.21"></script>
-    <script src="./js/index.js?v=1768998915"></script>
+    <script src="./js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="./search-data.js?v=1768998915"></script>
+    <script src="./search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/search-data.js b/docs/search-data.js
index 9a5e902..08d344d 100644
--- a/docs/search-data.js
+++ b/docs/search-data.js
@@ -1 +1 @@
-window.Aiken.initSearch([{"doc":"test_kit/collections/logic","title":"all_true","content":"all_true(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Equivalent to the old `list.and`","url":"test_kit/collections/logic.html#all_true"},{"doc":"test_kit/collections/logic","title":"any_true","content":"any_true(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Equivalent to the old `list.or`","url":"test_kit/collections/logic.html#any_true"},{"doc":"test_kit/collections/logic","title":"all_false","content":"all_false(bool_list: List&lt;Bool&gt;) -&gt; Bool\n The opposite of `all_true`","url":"test_kit/collections/logic.html#all_false"},{"doc":"test_kit/collections/logic","title":"any_false","content":"any_false(bool_list: List&lt;Bool&gt;) -&gt; Bool\n The opposite of `any_true`","url":"test_kit/collections/logic.html#any_false"},{"doc":"test_kit/collections/logic","title":"test_kit/collections/logic","content":"","url":"test_kit/collections/logic.html"},{"doc":"test_kit/fuzzy","title":"tuple","content":"tuple(a: Fuzzer&lt;a&gt;, b: Fuzzer&lt;b&gt;) -&gt; Fuzzer&lt;(a, b)&gt;\n A convenient way of generating tuples instead of doing [`map2`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map2)\n ```aiken\n fuzz.map2(\n   fuzzer_a, fuzzer_b,\n   fn(a, b) { (a, b) }\n )\n ```","url":"test_kit/fuzzy.html#tuple"},{"doc":"test_kit/fuzzy","title":"tuple3","content":"tuple3(a: Fuzzer&lt;a&gt;, b: Fuzzer&lt;b&gt;, c: Fuzzer&lt;c&gt;) -&gt; Fuzzer&lt;(a, b, c)&gt;\n A convenient way of generating tuple3 instead of doing [`map3`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map3)\n ```aiken\n fuzz.map3(\n   fuzzer_a, fuzzer_b, fuzzer_c,\n   fn(a, b, c) { (a, b, c) }\n )\n ```","url":"test_kit/fuzzy.html#tuple3"},{"doc":"test_kit/fuzzy","title":"tuple4","content":"tuple4(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d)&gt;\n A convenient way of generating tuple4 instead of doing [`map4`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map4)\n ```aiken\n fuzz.map4(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d,\n   fn(a, b, c, d) { (a, b, c, d) }\n )\n ```","url":"test_kit/fuzzy.html#tuple4"},{"doc":"test_kit/fuzzy","title":"tuple5","content":"tuple5(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e)&gt;\n A convenient way of generating tuple5 instead of doing [`map5`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map5)\n ```aiken\n fuzz.map5(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e,\n   fn(a, b, c, d, e) { (a, b, c, d, e) }\n )\n ```","url":"test_kit/fuzzy.html#tuple5"},{"doc":"test_kit/fuzzy","title":"tuple6","content":"tuple6(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f)&gt;\n A convenient way of generating tuple6 instead of doing [`map6`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map6)\n ```aiken\n fuzz.map6(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f,\n   fn(a, b, c, d, e, f) { (a, b, c, d, e, f) }\n )\n ```","url":"test_kit/fuzzy.html#tuple6"},{"doc":"test_kit/fuzzy","title":"tuple7","content":"tuple7(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g)&gt;\n A convenient way of generating tuple7 instead of doing [`map7`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map7)\n ```aiken\n fuzz.map7(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g,\n   fn(a, b, c, d, e, f, g) { (a, b, c, d, e, f, g) }\n )\n ```","url":"test_kit/fuzzy.html#tuple7"},{"doc":"test_kit/fuzzy","title":"tuple8","content":"tuple8(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n  h: Fuzzer&lt;h&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g, h)&gt;\n A convenient way of generating tuple8 instead of doing [`map8`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map8)\n ```aiken\n fuzz.map8(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h,\n   fn(a, b, c, d, e, f, g, h) { (a, b, c, d, e, f, g, h) }\n )\n ```","url":"test_kit/fuzzy.html#tuple8"},{"doc":"test_kit/fuzzy","title":"tuple9","content":"tuple9(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n  h: Fuzzer&lt;h&gt;,\n  i: Fuzzer&lt;i&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g, h, i)&gt;\n A convenient way of generating tuple9 instead of doing [`map9`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map9)\n ```aiken\n fuzz.map9(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h, fuzzer_i,\n   fn(a, b, c, d, e, f, g, h, i) { (a, b, c, d, e, f, g, h, i) }\n )\n ```","url":"test_kit/fuzzy.html#tuple9"},{"doc":"test_kit/fuzzy","title":"unique","content":"unique(fuzzer: Fuzzer&lt;a&gt;, count: Int) -&gt; Fuzzer&lt;List&lt;a&gt;&gt;\n Generates a list of `n` unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique"},{"doc":"test_kit/fuzzy","title":"unique2","content":"unique2(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a)&gt;\n Generates a tuple of 2 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique2"},{"doc":"test_kit/fuzzy","title":"unique3","content":"unique3(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a)&gt;\n Generates a tuple of 3 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique3"},{"doc":"test_kit/fuzzy","title":"unique4","content":"unique4(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a)&gt;\n Generates a tuple of 4 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique4"},{"doc":"test_kit/fuzzy","title":"unique5","content":"unique5(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a)&gt;\n Generates a tuple of 5 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique5"},{"doc":"test_kit/fuzzy","title":"unique6","content":"unique6(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a)&gt;\n Generates a tuple of 6 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique6"},{"doc":"test_kit/fuzzy","title":"unique7","content":"unique7(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a)&gt;\n Generates a tuple of 7 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique7"},{"doc":"test_kit/fuzzy","title":"unique8","content":"unique8(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a, a)&gt;\n Generates a tuple of 8 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique8"},{"doc":"test_kit/fuzzy","title":"unique9","content":"unique9(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a, a, a)&gt;\n Generates a tuple of 9 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique9"},{"doc":"test_kit/fuzzy","title":"test_kit/fuzzy","content":"","url":"test_kit/fuzzy.html"},{"doc":"test_kit/collections","title":"list_and","content":"list_and(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Tells whether all of the `booleans` are `true`","url":"test_kit/collections.html#list_and"},{"doc":"test_kit/collections","title":"list_or","content":"list_or(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Tells whether any of the `booleans` is `true`","url":"test_kit/collections.html#list_or"},{"doc":"test_kit/collections","title":"zip3","content":"zip3(az: List&lt;a&gt;, bz: List&lt;b&gt;, cz: List&lt;c&gt;) -&gt; List&lt;(a, b, c)&gt;\n Combine 3 lists together into a list of 3-tuple.","url":"test_kit/collections.html#zip3"},{"doc":"test_kit/collections","title":"unzip3","content":"unzip3(abc: List&lt;(a, b, c)&gt;) -&gt; (List&lt;a&gt;, List&lt;b&gt;, List&lt;c&gt;)\n Decompose a list of 3-tuple into a tuple of 3 lists.","url":"test_kit/collections.html#unzip3"},{"doc":"test_kit/collections","title":"test_kit/collections","content":"","url":"test_kit/collections.html"},{"doc":"test_kit","title":"print","content":"print(label: ByteArray, data: Data) -&gt; Void\n Pretty-print data with label. This function calls\n [`fuzz.label`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#label)\n internally, so it will work with property testing.","url":"test_kit.html#print"},{"doc":"test_kit","title":"Any","content":"Any = Data\n\n","url":"test_kit.html#Any"},{"doc":"test_kit","title":"test_kit","content":"","url":"test_kit.html"},{"doc":"test_kit/tx/mock","title":"mock_hash","content":"mock_hash(from: Any, size: Int) -&gt; ByteArray\n Mocks any hash. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n The second parameter, `size: Int`, determines the byte length of the resulting mock hash.\n Smaller size than the length of the `from` argument will NOT truncate it,\n but 0 or negative size may cause panic or an unexpected behavior!\n\n Usage examples:\n ```aiken\n mock_hash(1, 2) == #&quot;0001&quot;\n mock_hash(345, 6) == #&quot;000000000345&quot;\n mock_hash(#&quot;af&quot;, 4) == #&quot;000000af&quot;\n mock_hash(&quot;Abc&quot;, 3) == #&quot;416263&quot;\n mock_hash(True, 5) == #&quot;0000D87A80&quot;\n mock_hash(None, 7) == #&quot;00000000D87A80&quot;\n mock_hash(Void, 1) == #&quot;D87980&quot;\n mock_hash(Never, 1) == #&quot;D87A80&quot;\n mock_hash(Never, 0) == #&quot;D87A80&quot;\n mock_hash([], 1) == #&quot;80&quot;\n mock_hash([], 0) == #&quot;80&quot;\n mock_hash([], -1) == #&quot;80&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash"},{"doc":"test_kit/tx/mock","title":"mock_hash_from_bytearray","content":"mock_hash_from_bytearray(bs: ByteArray, size: Int) -&gt; ByteArray\n Mocks any hash from [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray).\n\n The second parameter, `size: Int`, determines the byte length of the resulting mock hash.\n Smaller size than the length of the `from` argument will NOT truncate it.\n\n Usage examples:\n ```aiken\n mock_hash_from_bytearray(#&quot;af&quot;, 4) == #&quot;000000af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, 3) == #&quot;416263&quot;\n mock_hash_from_bytearray(#&quot;af&quot;, 2) == #&quot;00af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, 1) == #&quot;416263&quot;\n mock_hash_from_bytearray(#&quot;af&quot;, 0) == #&quot;af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, -1) == #&quot;416263&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash_from_bytearray"},{"doc":"test_kit/tx/mock","title":"mock_hash_from_int","content":"mock_hash_from_int(i: Int, size: Int) -&gt; ByteArray\n Mocks any hash from [`Int`](https://aiken-lang.org/language-tour/primitive-types#int).\n\n &gt; [!IMPORTANT]\n &gt; NEGATIVE value for the first parameter is acceptable,\n &gt; but combined with 0 or less second argument value may\n &gt; cause panic or an unexpected behavior!\n\n Usage examples:\n ```aiken\n mock_hash_from_int(1, 2) == #&quot;0001&quot;\n mock_hash_from_int(345, 6) == #&quot;000000000345&quot;\n mock_hash_from_int(1, 0) == #&quot;01&quot;\n mock_hash_from_int(345, 0) == #&quot;0345&quot;\n mock_hash_from_int(1, -2) =&gt; 💥\n mock_hash_from_int(345, -6) =&gt; 💥\n mock_hash_from_int(-1, 2) == #&quot;9999&quot;\n mock_hash_from_int(-345, 6) == #&quot;999999999655&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash_from_int"},{"doc":"test_kit/tx/mock","title":"mock_blake2b_224","content":"mock_blake2b_224(from: Any) -&gt; Hash&lt;Blake2b_224, ByteArray&gt;\n Mocks a Blake2b-224 Hash. It is 28-byte long.\n This function is not meant to be called directly,\n although there&#39;s no restriction.\n It is used by:\n - [`mock_verification_key_hash`](#mock_verification_key_hash)\n - [`mock_script_hash`](#mock_script_hash)\n - [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_blake2b_224"},{"doc":"test_kit/tx/mock","title":"mock_blake2b_256","content":"mock_blake2b_256(from: Any) -&gt; Hash&lt;Blake2b_256, ByteArray&gt;\n Mocks a Blake2b-256 Hash. It is 32-byte long.\n This function is not meant to be called directly,\n although there&#39;s no restriction.\n It is used by:\n - [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_blake2b_256"},{"doc":"test_kit/tx/mock","title":"mock_address","content":"mock_address(from_payment: Any, from_stake: Any) -&gt; Address\n Mocks an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n with `VerificationKey` payment and stake credentials.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_key = mock_address(123, False) // if 2nd arg is False | Void | [] | &quot;&quot; | 0, then there&#39;s no staking part\n address_key == from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n // use cardano/address.{from_verification_key, with_delegation_key}\n let address_key_key = mock_address(456, 789)\n address_key_key == (\n   from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n     |&gt; with_delegation_key(#&quot;00000000000000000000000000000000000000000000000000000789&quot;)\n )\n ```\n\n &gt; [!NOTE]\n &gt; `from_payment` and `from_stake` can have different data types. If `from_stake` is `False` | `Void` | `[]` | `&quot;&quot;` | `0`,\n &gt; then there&#39;s no staking part (`stake_credential: None`)","url":"test_kit/tx/mock.html#mock_address"},{"doc":"test_kit/tx/mock","title":"mock_script_address","content":"mock_script_address(from_payment: Any, from_stake: Any) -&gt; Address\n Similar to [`mock_address`](#mock_address), but with `Script` payment and stake credentials.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_script = mock_script_address(123, Void)\n address_script == from_script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n // use cardano/address.{from_script, with_delegation_script}\n let address_script_script = mock_script_address(456, 789)\n address_script_script == (\n   from_script(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n     |&gt; with_delegation_script(#&quot;00000000000000000000000000000000000000000000000000000789&quot;)\n )\n ```\n\n &gt; [!NOTE]\n &gt; `from_payment` and `from_stake` can have different data types. If `from_stake` is `False` | `Void` | `[]` | `&quot;&quot;` | `0`,\n &gt; then there&#39;s no staking part (`stake_credential: None`)","url":"test_kit/tx/mock.html#mock_script_address"},{"doc":"test_kit/tx/mock","title":"mock_address_with_delegation_script","content":"mock_address_with_delegation_script(\n  from_payment: Any,\n  from_stake: Any,\n) -&gt; Address\n Similar to [`mock_address`](#mock_address), but with `Script` stake credential,\n and the staking part (`stake_credential`) will NEVER be `None`.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_key_script = mock_address_with_delegation_script(123, 456)\n address_key_script == (\n   from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n     |&gt; with_delegation_script(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n )\n // use cardano/address.{from_verification_key, with_delegation_script}\n ```","url":"test_kit/tx/mock.html#mock_address_with_delegation_script"},{"doc":"test_kit/tx/mock","title":"mock_script_address_with_delegation_key","content":"mock_script_address_with_delegation_key(\n  from_payment: Any,\n  from_stake: Any,\n) -&gt; Address\n Similar to [`mock_address_with_delegation_script`](#mock_address_with_delegation_script),\n but it&#39;s the other way around. The payment part is `Script` credential, and the staking part is\n `VerificationKey` credential. The staking part (`stake_credential`) will NEVER be `None`.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_script_key = mock_script_address_with_delegation_key(123, 456)\n address_script_key == (\n   from_script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n     |&gt; with_delegation_key(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n )\n // use cardano/address.{from_script, with_delegation_key}\n ```","url":"test_kit/tx/mock.html#mock_script_address_with_delegation_key"},{"doc":"test_kit/tx/mock","title":"mock_address_from_verification_key","content":"mock_address_from_verification_key(from: Any) -&gt; Address\n Constructs an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n from a mock verification key hash. The resulting address has no delegation rights.\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_address_from_verification_key(1) == mock_address(1, 0)\n ```","url":"test_kit/tx/mock.html#mock_address_from_verification_key"},{"doc":"test_kit/tx/mock","title":"mock_address_from_script","content":"mock_address_from_script(from: Any) -&gt; Address\n Constructs an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n from a mock script hash. The address has no delegation rights.\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_address_from_script(2) == mock_script_address(2, 0)\n ```","url":"test_kit/tx/mock.html#mock_address_from_script"},{"doc":"test_kit/tx/mock","title":"with_mock_delegation_key","content":"with_mock_delegation_key(address: Address, from: Any) -&gt; Address\n Sets the delegation part of an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n using a mock verification key hash. This is useful when combined with [`mock_address_from_verification_key`](#mock_address_from_verification_key)\n or [`mock_address_from_script`](#mock_address_from_script). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n (mock_address_from_verification_key(3)\n   |&gt; with_mock_delegation_key(4)\n ) == mock_address(3, 4)\n \n (mock_address_from_script(3)\n   |&gt; with_mock_delegation_key(4)\n ) == mock_script_address_with_delegation_key(3, 4)\n ```","url":"test_kit/tx/mock.html#with_mock_delegation_key"},{"doc":"test_kit/tx/mock","title":"with_mock_delegation_script","content":"with_mock_delegation_script(address: Address, from: Any) -&gt; Address\n Sets the delegation part of an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n using a mock script hash. This is useful when combined with [`mock_address_from_verification_key`](#mock_address_from_verification_key)\n or [`mock_address_from_script`](#mock_address_from_script). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n (mock_address_from_verification_key(5)\n   |&gt; with_mock_delegation_script(6)\n ) == mock_address_with_delegation_script(5, 6)\n \n (mock_address_from_script(5)\n   |&gt; with_mock_delegation_script(6)\n ) == mock_script_address(5, 6)\n ```","url":"test_kit/tx/mock.html#with_mock_delegation_script"},{"doc":"test_kit/tx/mock","title":"mock_verification_key_credential","content":"mock_verification_key_credential(from: Any) -&gt; Credential\n Mocks a `VerificationKey` credential. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_verification_key_credential(1) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n mock_verification_key_credential(123) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n mock_verification_key_credential(#&quot;af&quot;) == VerificationKey(#&quot;000000000000000000000000000000000000000000000000000000af&quot;)\n mock_verification_key_credential(&quot;Abc&quot;) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000416263&quot;)\n mock_verification_key_credential(True) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential(None) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential(Void) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87980&quot;)\n mock_verification_key_credential(Never) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential([]) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000080&quot;)\n // use cardano/address.{VerificationKey}\n ```","url":"test_kit/tx/mock.html#mock_verification_key_credential"},{"doc":"test_kit/tx/mock","title":"mock_script_credential","content":"mock_script_credential(from: Any) -&gt; Credential\n Mocks a `Script` credential. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_script_credential(1) == Script(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n mock_script_credential(123) == Script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n mock_script_credential(#&quot;af&quot;) == Script(#&quot;000000000000000000000000000000000000000000000000000000af&quot;)\n mock_script_credential(&quot;Abc&quot;) == Script(#&quot;00000000000000000000000000000000000000000000000000416263&quot;)\n mock_script_credential(True) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential(None) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential(Void) == Script(#&quot;00000000000000000000000000000000000000000000000000D87980&quot;)\n mock_script_credential(Never) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential([]) == Script(#&quot;00000000000000000000000000000000000000000000000000000080&quot;)\n // use cardano/address.{Script}\n ```","url":"test_kit/tx/mock.html#mock_script_credential"},{"doc":"test_kit/tx/mock","title":"mock_verification_key_hash","content":"mock_verification_key_hash(from: Any) -&gt; VerificationKeyHash\n Mocks a [`VerificationKeyHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#VerificationKeyHash).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_verification_key_hash(1) == #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n mock_verification_key_hash(123) == #&quot;00000000000000000000000000000000000000000000000000000123&quot;\n mock_verification_key_hash(#&quot;af&quot;) == #&quot;000000000000000000000000000000000000000000000000000000af&quot;\n mock_verification_key_hash(&quot;Abc&quot;) == #&quot;00000000000000000000000000000000000000000000000000416263&quot;\n mock_verification_key_hash(True) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash(None) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash(Void) == #&quot;00000000000000000000000000000000000000000000000000D87980&quot;\n mock_verification_key_hash(Never) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash([]) == #&quot;00000000000000000000000000000000000000000000000000000080&quot;\n ```\n \n Alias: [`mock_vkh`](#mock_vkh)","url":"test_kit/tx/mock.html#mock_verification_key_hash"},{"doc":"test_kit/tx/mock","title":"mock_vkh","content":"mock_vkh(from: Any) -&gt; VerificationKeyHash\n See: [`mock_verification_key_hash`](#mock_verification_key_hash)","url":"test_kit/tx/mock.html#mock_vkh"},{"doc":"test_kit/tx/mock","title":"mock_script_hash","content":"mock_script_hash(from: Any) -&gt; ScriptHash\n Mocks a [`ScriptHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#ScriptHash).\n Under the hood, it&#39;s the same as [`mock_verification_key_hash`](#mock_verification_key_hash)\n or [`mock_vkh`](#mock_vkh). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_script_hash(1) == #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n mock_script_hash(123) == #&quot;00000000000000000000000000000000000000000000000000000123&quot;\n mock_script_hash(#&quot;af&quot;) == #&quot;000000000000000000000000000000000000000000000000000000af&quot;\n mock_script_hash(&quot;Abc&quot;) == #&quot;00000000000000000000000000000000000000000000000000416263&quot;\n mock_script_hash(True) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash(None) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash(Void) == #&quot;00000000000000000000000000000000000000000000000000D87980&quot;\n mock_script_hash(Never) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash([]) == #&quot;00000000000000000000000000000000000000000000000000000080&quot;\n ```\n \n Alias: [`mock_sh`](#mock_sh)","url":"test_kit/tx/mock.html#mock_script_hash"},{"doc":"test_kit/tx/mock","title":"mock_sh","content":"mock_sh(from: Any) -&gt; ScriptHash\n See: [`mock_script_hash`](#mock_script_hash)","url":"test_kit/tx/mock.html#mock_sh"},{"doc":"test_kit/tx/mock","title":"mock_asset","content":"mock_asset(from: Any, asset_name: AssetName, quantity: Int) -&gt; Value\n Constructs a [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value)\n from a mock [`PolicyId`](#mock_policy_id), [`AssetName`](https://aiken-lang.github.io/stdlib/cardano/assets.html#AssetName)\n and a given `quantity`. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_asset(&quot;PolicyId&quot;, &quot;NFT&quot;, 1)\n   |&gt; add(#&quot;0000000000000000000000000000000000000000506F6C6963794964&quot;, &quot;NFT&quot;, -1)\n   |&gt; is_zero() // True\n // use cardano/assets.{add, is_zero}\n ```\n\n &gt; [!NOTE]\n &gt; You can also only mock the Policy ID, see: [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_asset"},{"doc":"test_kit/tx/mock","title":"mock_policy_id","content":"mock_policy_id(from: Any) -&gt; PolicyId\n Mocks a [`PolicyId`](https://aiken-lang.github.io/stdlib/cardano/assets.html#PolicyId).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n from_asset(mock_policy_id(123), &quot;NFT&quot;, 1)\n   |&gt; add(#&quot;00000000000000000000000000000000000000000000000000000123&quot;, &quot;NFT&quot;, -1)\n   |&gt; is_zero() // True\n // use cardano/assets.{from_asset, add, is_zero}\n ```\n \n Alias: [`mock_policy`](#mock_policy)","url":"test_kit/tx/mock.html#mock_policy_id"},{"doc":"test_kit/tx/mock","title":"mock_policy","content":"mock_policy(from: Any) -&gt; PolicyId\n See: [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_policy"},{"doc":"test_kit/tx/mock","title":"mock_output_reference","content":"mock_output_reference(from: Any, output_index: Int) -&gt; OutputReference\n Mocks an [`OutputReference`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#OutputReference).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_output_reference(123, 45) == OutputReference {\n   transaction_id: #&quot;0000000000000000000000000000000000000000000000000000000000000123&quot;,\n   output_index: 45,\n }\n // use cardano/transaction.{OutputReference}\n ```\n\n Aliases:\n - [`mock_out_ref`](#mock_out_ref)\n - [`mock_o_ref`](#mock_o_ref)\n\n &gt; [!NOTE]\n &gt; You can also only mock the Transaction ID, see: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_output_reference"},{"doc":"test_kit/tx/mock","title":"mock_out_ref","content":"mock_out_ref(from: Any, output_index: Int) -&gt; OutputReference\n See: [`mock_output_reference`](#mock_output_reference)","url":"test_kit/tx/mock.html#mock_out_ref"},{"doc":"test_kit/tx/mock","title":"mock_o_ref","content":"mock_o_ref(from: Any, output_index: Int) -&gt; OutputReference\n See: [`mock_output_reference`](#mock_output_reference)","url":"test_kit/tx/mock.html#mock_o_ref"},{"doc":"test_kit/tx/mock","title":"mock_transaction_id","content":"mock_transaction_id(from: Any) -&gt; TransactionId\n Mocks a [`TransactionId`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#TransactionId).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n OutputReference(mock_transaction_id(1), 0) == mock_output_reference(1, 0)\n // use cardano/transaction.{OutputReference}\n ```\n \n Aliases:\n - [`mock_tran_id`](#mock_tran_id)\n - [`mock_txn_id`](#mock_txn_id)\n - [`mock_tx_id`](#mock_tx_id)\n - [`mock_tx_hash`](#mock_tx_hash)\n - [`mock_txn_hash`](#mock_txn_hash)\n - [`mock_tran_hash`](#mock_tran_hash)\n - [`mock_transaction_hash`](#mock_transaction_hash)","url":"test_kit/tx/mock.html#mock_transaction_id"},{"doc":"test_kit/tx/mock","title":"mock_tran_id","content":"mock_tran_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tran_id"},{"doc":"test_kit/tx/mock","title":"mock_txn_id","content":"mock_txn_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_txn_id"},{"doc":"test_kit/tx/mock","title":"mock_tx_id","content":"mock_tx_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tx_id"},{"doc":"test_kit/tx/mock","title":"mock_tx_hash","content":"mock_tx_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tx_hash"},{"doc":"test_kit/tx/mock","title":"mock_txn_hash","content":"mock_txn_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_txn_hash"},{"doc":"test_kit/tx/mock","title":"mock_tran_hash","content":"mock_tran_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tran_hash"},{"doc":"test_kit/tx/mock","title":"mock_transaction_hash","content":"mock_transaction_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_transaction_hash"},{"doc":"test_kit/tx/mock","title":"test_kit/tx/mock","content":" A fancy way to construct mock hashes, such as:\n - [`VerificationKeyHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#VerificationKeyHash)\n - [`ScriptHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#ScriptHash)\n - [`PolicyId`](https://aiken-lang.github.io/stdlib/cardano/assets.html#PolicyId)\n - [`TransactionId`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#TransactionId)\n - and any other hashes\n\n Usage examples:\n ```aiken\n // Mock Address:\n let address_key = mock_address(1, False) // if 2nd arg is False | Void | [] | &quot;&quot; | 0, then there&#39;s no staking part\n address_key == from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n // use cardano/address.{from_verification_key}\n\n // Mock Credential:\n mock_verification_key_credential(2) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000002&quot;)\n mock_script_credential(3) == Script(#&quot;00000000000000000000000000000000000000000000000000000003&quot;)\n // use cardano/address.{VerificationKey, Script}\n (mock_verification_key_hash(4) |&gt; VerificationKey) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000004&quot;)\n (mock_script_hash(5) |&gt; Script) == Script(#&quot;00000000000000000000000000000000000000000000000000000005&quot;)\n \n // Mock Asset:\n let mint = mock_asset(6, &quot;NFT&quot;, 1)\n let burn = from_asset(mock_policy_id(6), &quot;NFT&quot;, -1) // you can also only mock the Policy ID\n mint\n   |&gt; merge(burn)\n   |&gt; is_zero() // True\n // use cardano/assets.{from_asset, merge, is_zero}\n \n // Mock Output Reference:\n let o_ref = mock_output_reference(7, 0) // aliases: mock_out_ref, mock_o_ref\n and {\n   o_ref == OutputReference(mock_transaction_id(7), 0), // you can also only mock the Transaction ID\n   o_ref == OutputReference {\n     transaction_id: #&quot;0000000000000000000000000000000000000000000000000000000000000007&quot;,\n     output_index: 0,\n   },\n }\n // use cardano/transaction.{OutputReference}\n \n // Mock any hash:\n mock_hash(8, 2) == #&quot;0008&quot;\n mock_hash_from_int(9, 3) == #&quot;000009&quot;\n mock_hash_from_bytearray(#&quot;10&quot;, 4) == #&quot;00000010&quot;\n ```\n\n &gt; [!NOTE]\n &gt; Constructing mock hashes this way will add to your Memory and CPU Usages **during testing**!\n &gt; For example: `mock_sh(1)` will generate `#&quot;00000000000000000000000000000000000000000000000000000001&quot;`,\n &gt; but notice the following Memory and CPU Usages.\n &gt; ```aiken\n &gt; /// Aiken v1.1.9 mem: 261806, cpu: 75093536\n &gt; test mock() {\n &gt;   trace mock_sh(1)\n &gt;   True\n &gt; }\n &gt; \n &gt; /// Aiken v1.1.9 mem: 254825, cpu: 71651198\n &gt; test no_mock() {\n &gt;   trace #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n &gt;   True\n &gt; }\n &gt; ```","url":"test_kit/tx/mock.html"},{"doc":"config","title":"now","content":"now: Int = 1768998897000\n","url":"config.html#now"},{"doc":"config","title":"config","content":"","url":"config.html"},{"doc":"test_kit/time/unwrap","title":"finite_start_of","content":"finite_start_of(interval: Interval) -&gt; PosixTime\n Returns the **normalized lower-bound** `Posixtime` of an `interval`\n &gt; [!WARNING]\n &gt; Will panic if `lower_bound` is not `Finite`","url":"test_kit/time/unwrap.html#finite_start_of"},{"doc":"test_kit/time/unwrap","title":"finite_end_of","content":"finite_end_of(interval: Interval) -&gt; PosixTime\n Returns the **normalized upper-bound** `PosixTime` of an `interval`\n &gt; [!WARNING]\n &gt; Will panic if `upper_bound` is not `Finite`","url":"test_kit/time/unwrap.html#finite_end_of"},{"doc":"test_kit/time/unwrap","title":"test_kit/time/unwrap","content":" A convenient way to unwrap `Finite(PosixTime)` from an `Interval`,\n but will **panic** if the interval bound is not `Finite`.","url":"test_kit/time/unwrap.html"},{"doc":"test_kit/tx","title":"set_id","content":"set_id(tx: Transaction, id: TransactionId) -&gt; Transaction\n Set `Transaction.id`.\n The default value is `#&quot;0000000000000000000000000000000000000000000000000000000000000000&quot;`","url":"test_kit/tx.html#set_id"},{"doc":"test_kit/tx","title":"set_validity_range","content":"set_validity_range(\n  tx: Transaction,\n  validity_range: ValidityRange,\n) -&gt; Transaction\n Set `Transaction.validity_range`.\n The default value is `interval.everything`","url":"test_kit/tx.html#set_validity_range"},{"doc":"test_kit/tx","title":"set_fee","content":"set_fee(tx: Transaction, fee: assets.Lovelace) -&gt; Transaction\n Set `Transaction.fee`.\n The default value is `0`","url":"test_kit/tx.html#set_fee"},{"doc":"test_kit/tx","title":"add_tx_input","content":"add_tx_input(tx: Transaction, tx_in: transaction.Input) -&gt; Transaction\n Concat `tx_in` to `Transaction.inputs`.\n The new `tx_in` is placed at the end of the list.\n\n Example,\n ```\n let tx_in = new_tx_input(...)\n     |&gt; set_datum_of_tx_input(...)\n     |&gt; attach_ref_script_to_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_input(tx_in)\n ```","url":"test_kit/tx.html#add_tx_input"},{"doc":"test_kit/tx","title":"new_tx_input","content":"new_tx_input(\n  output_reference: OutputReference,\n  address: Address,\n) -&gt; transaction.Input\n Initialize a transaction input with zero assets value, no datum, and no reference script.\n\n Example,\n ```\n let output_reference = OutputReference(#&quot;0000000000000000000000000000000000000000000000000000000000000064&quot;, 0)\n let address = from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n\n let tx_in = new_tx_input(output_reference, address)\n ```","url":"test_kit/tx.html#new_tx_input"},{"doc":"test_kit/tx","title":"with_asset_of_tx_input","content":"with_asset_of_tx_input(\n  input: transaction.Input,\n  asset: assets.Value,\n) -&gt; transaction.Input\n Add an asset to a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; with_asset_of_tx_input(from_lovelace(2_000_000))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId1&quot;, &quot;Nft1&quot;, 1))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId1&quot;, &quot;Token1&quot;, 3_000))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId2&quot;, &quot;Nft2&quot;, 1))\n ```","url":"test_kit/tx.html#with_asset_of_tx_input"},{"doc":"test_kit/tx","title":"set_datum_of_tx_input","content":"set_datum_of_tx_input(\n  input: transaction.Input,\n  datum: transaction.Datum,\n) -&gt; transaction.Input\n Set a datum of a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; set_datum_of_tx_input(InlineDatum(...))\n ```","url":"test_kit/tx.html#set_datum_of_tx_input"},{"doc":"test_kit/tx","title":"attach_ref_script_to_tx_input","content":"attach_ref_script_to_tx_input(\n  input: transaction.Input,\n  ref_script: ScriptHash,\n) -&gt; transaction.Input\n Attach a reference script to a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; attach_ref_script_to_tx_input(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n ```","url":"test_kit/tx.html#attach_ref_script_to_tx_input"},{"doc":"test_kit/tx","title":"remove_ref_script_from_tx_input","content":"remove_ref_script_from_tx_input(input: transaction.Input) -&gt; transaction.Input\n Remove reference script from a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; attach_ref_script_to_tx_input(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n     |&gt; remove_ref_script_from_tx_input()\n ```","url":"test_kit/tx.html#remove_ref_script_from_tx_input"},{"doc":"test_kit/tx","title":"add_tx_ref_input","content":"add_tx_ref_input(tx: Transaction, tx_ref_in: transaction.Input) -&gt; Transaction\n Concat `tx_ref_in` to `Transaction.reference_inputs`.\n The new `tx_ref_in` is placed at the end of the list.\n\n Example,\n ```\n let tx_ref_in = new_tx_input(...)\n     |&gt; set_datum_of_tx_input(...)\n     |&gt; attach_ref_script_to_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_ref_input(tx_ref_in)\n ```","url":"test_kit/tx.html#add_tx_ref_input"},{"doc":"test_kit/tx","title":"add_tx_output","content":"add_tx_output(tx: Transaction, tx_out: transaction.Output) -&gt; Transaction\n Concat `tx_out` to `Transaction.outputs`.\n The new `tx_out` is placed at the end of the list.\n\n Example,\n ```\n let tx_out = new_tx_output(...)\n     |&gt; set_datum_of_tx_output(...)\n     |&gt; attach_ref_script_to_tx_output(...)\n     |&gt; add_asset_to_tx_output(...)\n     |&gt; add_asset_to_tx_output(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_output(tx_out)\n ```","url":"test_kit/tx.html#add_tx_output"},{"doc":"test_kit/tx","title":"new_tx_output","content":"new_tx_output(address: Address) -&gt; transaction.Output\n Initialize a transaction output with zero assets value, no datum, and no reference script.\n\n Example,\n ```\n let address = from_script(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n let tx_out = new_tx_output(address)\n ```","url":"test_kit/tx.html#new_tx_output"},{"doc":"test_kit/tx","title":"add_asset_to_tx_output","content":"add_asset_to_tx_output(\n  output: transaction.Output,\n  asset: assets.Value,\n) -&gt; transaction.Output\n Add an asset to a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; add_asset_to_tx_output(from_lovelace(2_000_000))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId1&quot;, &quot;Nft1&quot;, 1))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId1&quot;, &quot;Token1&quot;, 3_000))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId2&quot;, &quot;Nft2&quot;, 1))\n ```","url":"test_kit/tx.html#add_asset_to_tx_output"},{"doc":"test_kit/tx","title":"set_datum_of_tx_output","content":"set_datum_of_tx_output(\n  output: transaction.Output,\n  datum: transaction.Datum,\n) -&gt; transaction.Output\n Set a datum of a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; set_datum_of_tx_output(InlineDatum(...))\n ```","url":"test_kit/tx.html#set_datum_of_tx_output"},{"doc":"test_kit/tx","title":"attach_ref_script_to_tx_output","content":"attach_ref_script_to_tx_output(\n  output: transaction.Output,\n  ref_script: ScriptHash,\n) -&gt; transaction.Output\n Attach a reference script to a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; attach_ref_script_to_tx_output(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n ```","url":"test_kit/tx.html#attach_ref_script_to_tx_output"},{"doc":"test_kit/tx","title":"remove_ref_script_from_tx_output","content":"remove_ref_script_from_tx_output(\n  output: transaction.Output,\n) -&gt; transaction.Output\n Remove reference script from a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; attach_ref_script_to_tx_output(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n     |&gt; remove_ref_script_from_tx_output()\n ```","url":"test_kit/tx.html#remove_ref_script_from_tx_output"},{"doc":"test_kit/tx","title":"add_mint","content":"add_mint(tx: Transaction, asset: assets.Value) -&gt; Transaction\n Merge `asset` to `Transaction.mint`","url":"test_kit/tx.html#add_mint"},{"doc":"test_kit/tx","title":"add_certificate","content":"add_certificate(tx: Transaction, certificate: Certificate) -&gt; Transaction\n Concat `certificate` to `Transaction.certificates`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_certificate"},{"doc":"test_kit/tx","title":"add_withdrawal","content":"add_withdrawal(\n  tx: Transaction,\n  withdrawal_key: address.Credential,\n  withdrawal_value: assets.Lovelace,\n) -&gt; Transaction\n Merge `withdrawal` to `Transaction.withdrawals`","url":"test_kit/tx.html#add_withdrawal"},{"doc":"test_kit/tx","title":"add_signatory","content":"add_signatory(tx: Transaction, signatory: VerificationKeyHash) -&gt; Transaction\n Concat `signatory` to `Transaction.extra_signatories`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_signatory"},{"doc":"test_kit/tx","title":"add_datum","content":"add_datum(\n  tx: Transaction,\n  datum_key: DataHash,\n  datum_value: Data,\n) -&gt; Transaction\n Insert `datum` to `Transaction.datums`.\n If the key already exists, its value is overridden.","url":"test_kit/tx.html#add_datum"},{"doc":"test_kit/tx","title":"add_redeemer","content":"add_redeemer(\n  tx: Transaction,\n  redeemer_key: ScriptPurpose,\n  redeemer_value: transaction.Redeemer,\n) -&gt; Transaction\n Repsert `redeemer` to `Transaction.redeemers`.\n If the key already exists, its value is replaced.","url":"test_kit/tx.html#add_redeemer"},{"doc":"test_kit/tx","title":"add_vote","content":"add_vote(\n  tx: Transaction,\n  vote_key: governance.Voter,\n  vote_value: Pairs&lt;GovernanceActionId, governance.Vote&gt;,\n) -&gt; Transaction\n Repsert `vote` to `Transaction.votes`.\n If the key already exists, its value is replaced.","url":"test_kit/tx.html#add_vote"},{"doc":"test_kit/tx","title":"add_proposal_procedure","content":"add_proposal_procedure(\n  tx: Transaction,\n  deposit: assets.Lovelace,\n  return_address: address.Credential,\n  governance_action: GovernanceAction,\n) -&gt; Transaction\n Concat `proposal_procedure` to `Transaction.proposal_procedures`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_proposal_procedure"},{"doc":"test_kit/tx","title":"set_current_treasury_amount","content":"set_current_treasury_amount(\n  tx: Transaction,\n  amount: assets.Lovelace,\n) -&gt; Transaction\n Set `Transaction.current_treasury_amount`","url":"test_kit/tx.html#set_current_treasury_amount"},{"doc":"test_kit/tx","title":"unset_current_treasury_amount","content":"unset_current_treasury_amount(tx: Transaction) -&gt; Transaction\n Unset `Transaction.current_treasury_amount`","url":"test_kit/tx.html#unset_current_treasury_amount"},{"doc":"test_kit/tx","title":"set_treasury_donation","content":"set_treasury_donation(tx: Transaction, donation: assets.Lovelace) -&gt; Transaction\n Set `Transaction.treasury_donation`","url":"test_kit/tx.html#set_treasury_donation"},{"doc":"test_kit/tx","title":"unset_treasury_donation","content":"unset_treasury_donation(tx: Transaction) -&gt; Transaction\n Unset `Transaction.treasury_donation`","url":"test_kit/tx.html#unset_treasury_donation"},{"doc":"test_kit/tx","title":"test_kit/tx","content":" Usage example:\n ```\n test positive_case() {\n   // Arrange:\n   let nft = from_asset(&quot;NftPolicy&quot;, &quot;NftName&quot;, 1)\n   let token = from_asset(&quot;TokenPolicy&quot;, &quot;TokenName&quot;, 10)\n   // use cardano/assets.{from_asset}\n   let asset_1 = from_asset(&quot;AssetPolicy1&quot;, &quot;AssetName1&quot;, 1)\n   let asset_2 = from_asset(&quot;AssetPolicy2&quot;, &quot;AssetName2&quot;, 1000)\n   let asset_2_partial = from_asset(&quot;AssetPolicy2&quot;, &quot;AssetName2&quot;, 100)\n\n   // test_kit/tx:\n   let tx_ref_in =\n     new_tx_input(\n       output_reference: OutputReference(&quot;TxRefInHash&quot;, 0),\n       address: &quot;ScriptHash1&quot; |&gt; from_script,\n     )\n       |&gt; with_asset_of_tx_input(2_000_000 |&gt; from_lovelace)\n       |&gt; with_asset_of_tx_input(token)\n\n   let tx_in =\n     new_tx_input(\n       output_reference: OutputReference(&quot;TxInHash&quot;, 1),\n       address: &quot;ScriptHash2&quot; |&gt; from_script,\n     )\n       |&gt; set_datum_of_tx_input(&quot;OldDatum&quot; |&gt; InlineDatum)\n       |&gt; with_asset_of_tx_input(4_000_000 |&gt; from_lovelace)\n       |&gt; with_asset_of_tx_input(nft)\n       |&gt; with_asset_of_tx_input(asset_1)\n       |&gt; with_asset_of_tx_input(asset_2)\n\n   let tx_out =\n     new_tx_output(address: &quot;ScriptHash2&quot; |&gt; from_script)\n       |&gt; set_datum_of_tx_output(&quot;NewDatum&quot; |&gt; InlineDatum)\n       |&gt; add_asset_to_tx_output(4_000_000 |&gt; from_lovelace)\n       |&gt; add_asset_to_tx_output(nft)\n       |&gt; add_asset_to_tx_output(asset_1)\n       |&gt; add_asset_to_tx_output(asset_2_partial)\n\n   let tx =\n     transaction.placeholder\n       |&gt; add_tx_ref_input(tx_ref_in)\n       |&gt; add_tx_input(tx_in)\n       |&gt; add_tx_output(tx_out)\n       |&gt; add_signatory(&quot;VerificationKeyHash&quot;)\n\n   // use test_kit.{print}\n   print(&quot;Tx&quot;, tx)\n\n   // Assert:\n   validator.validate.spend(None, Void, output_reference, tx)\n }\n ```","url":"test_kit/tx.html"},{"doc":"test_kit/fuzzy/fuzzer","title":"address_fuzzer","content":"address_fuzzer(\n  from: FromCredential,\n  with_delegation: WithDelegation,\n) -&gt; Fuzzer&lt;Address&gt;\n An [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address) fuzzer.\n See [`FromCredential`](#FromCredential) and [`WithDelegation`](#WithDelegation)\n for more information and usage examples.","url":"test_kit/fuzzy/fuzzer.html#address_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"credential_fuzzer","content":"credential_fuzzer(from: FromCredential) -&gt; Fuzzer&lt;address.Credential&gt;\n Fuzzes either `Script` or `VerificationKey` credentials determined by [`FromCredential`](#FromCredential)\n ```aiken\n credential_fuzzer(FromScript(Fuzzed))\n credential_fuzzer(FromKey(Fuzzed))\n credential_fuzzer(FromFuzzed)\n ```\n `FromScript` and `FromKey` with `Specified` [`CredentialHash`](#CredentialHash) are also supported\n but most of the time there&#39;s no reason to use a fuzzer for a known credential type and hash.","url":"test_kit/fuzzy/fuzzer.html#credential_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_hash_fuzzer","content":"script_hash_fuzzer() -&gt; Fuzzer&lt;ScriptHash&gt;\n Script Hash with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#script_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"verification_key_hash_fuzzer","content":"verification_key_hash_fuzzer() -&gt; Fuzzer&lt;VerificationKeyHash&gt;\n Verification Key Hash with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#verification_key_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"policy_id_fuzzer","content":"policy_id_fuzzer() -&gt; Fuzzer&lt;PolicyId&gt;\n Policy ID with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#policy_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"asset_name_fuzzer","content":"asset_name_fuzzer() -&gt; Fuzzer&lt;AssetName&gt;\n Asset Name with 0-32 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#asset_name_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"value_fuzzer","content":"value_fuzzer(min_lovelaces: assets.Lovelace) -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer,\n guaranteed to include some amount of ADA (minimum must be specified)\n\n Fuzzes a list of assets with some ADA with quantity of at least as the specified minimum amount, and 0-10 tokens:\n ```aiken\n assets.from_asset_list([\n   Pair(&quot;&quot;, [Pair(&quot;&quot;, lovelace_count)]),\n   ..,\n   Pair(policy_id, [Pair(token_name, quantity), ..])\n ])\n ```\n Where,\n - `lovelace_count` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(min_lovelaces)`\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"single_asset_value_fuzzer","content":"single_asset_value_fuzzer() -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer with a single asset.\n Randomly generates the Policy ID.\n\n Fuzzes the following token:\n ```aiken\n policy_id |&gt; assets.from_asset(token_name, quantity)\n ```\n Where,\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#single_asset_value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"single_specific_asset_value_fuzzer","content":"single_specific_asset_value_fuzzer(policy_id: PolicyId) -&gt; Fuzzer&lt;assets.Value&gt;\n A fuzzer for [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) with a single asset.\n Unsafely expects 28 bytes long Policy ID to be provided.\n\n Fuzzes the following token:\n ```aiken\n policy_id |&gt; assets.from_asset(token_name, quantity)\n ```\n Where,\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#single_specific_asset_value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"mint_fuzzer","content":"mint_fuzzer() -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer without any lovelaces.\n\n Fuzzes 1-10 tokens:\n ```aiken\n assets.from_asset_list([\n   Pair(policy_id, [Pair(token_name, quantity), ..])\n   ..,\n ])\n ```\n Where,\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#mint_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"stake_pool_id_fuzzer","content":"stake_pool_id_fuzzer() -&gt; Fuzzer&lt;StakePoolId&gt;\n Stake Pool ID with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#stake_pool_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"delegate_representative_fuzzer","content":"delegate_representative_fuzzer(\n  when_registered: FromCredential,\n) -&gt; Fuzzer&lt;DelegateRepresentative&gt;\n Fuzzes either `Registered`([`FromCredential`](#FromCredential)) | `AlwaysAbstain` | `AlwaysNoConfidence`\n ```aiken\n // Fuzzes either:\n // - Registered(&quot;KNOWN_SCRIPT_HASH&quot; |&gt; Script)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)))\n \n // Fuzzes either:\n // - Registered(Any Script)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromScript(Fuzzed))\n \n // Fuzzes either:\n // - Registered(&quot;KNOWN_KEY_HASH&quot; |&gt; VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromKey(Specified(&quot;KNOWN_KEY_HASH&quot;)))\n \n // Fuzzes either:\n // - Registered(Any VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromKey(Fuzzed))\n \n // Fuzzes either:\n // - Registered(Any Script or Any VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromFuzzed)\n ```","url":"test_kit/fuzzy/fuzzer.html#delegate_representative_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"delegate_fuzzer","content":"delegate_fuzzer(\n  when_block_production: StakePoolHash,\n  when_vote: VoteDelegateRepresentative,\n  when_both: (StakePoolHash, VoteDelegateRepresentative),\n) -&gt; Fuzzer&lt;certificate.Delegate&gt;\n Fuzzes either:\n - `DelegateBlockProduction`([`StakePoolHash`](#StakePoolHash))\n - `DelegateVote`([`VoteDelegateRepresentative`](#VoteDelegateRepresentative))\n - `DelegateBoth`([`StakePoolHash`](#StakePoolHash), [`VoteDelegateRepresentative`](#VoteDelegateRepresentative))","url":"test_kit/fuzzy/fuzzer.html#delegate_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"constitution_fuzzer","content":"constitution_fuzzer(some_guardrails: CredentialHash) -&gt; Fuzzer&lt;Constitution&gt;\n Fuzzes a [`Constitution`](https://aiken-lang.github.io/stdlib/cardano/governance.html#Constitution)\n with either `Some`(`&quot;KNOWN_SCRIPT_HASH&quot;` | `Any Script Hash`) or `None`\n ```aiken\n // Fuzzes either:\n // - Constitution(Some(&quot;KNOWN_SCRIPT_HASH&quot; |&gt; Script))\n // - Constitution(None)\n constitution_fuzzer(some_guardrails: Specified(&quot;KNOWN_SCRIPT_HASH&quot;))\n \n // Fuzzes either:\n // - Constitution(Some(Any Script Hash))\n // - Constitution(None)\n constitution_fuzzer(some_guardrails: Fuzzed)\n ```","url":"test_kit/fuzzy/fuzzer.html#constitution_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"governance_action_id_fuzzer","content":"governance_action_id_fuzzer() -&gt; Fuzzer&lt;GovernanceActionId&gt;\n Governance Action ID fuzzer,\n Transaction ID with 32 bytes,\n and output index between 0 and 512.","url":"test_kit/fuzzy/fuzzer.html#governance_action_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"vote_fuzzer","content":"vote_fuzzer() -&gt; Fuzzer&lt;Vote&gt;\n Fuzzes either `Yes` | `No` | `Abstain`","url":"test_kit/fuzzy/fuzzer.html#vote_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"voter_fuzzer","content":"voter_fuzzer(\n  when_constitutional_committee_member: FromCredential,\n  when_delegate_representative: FromCredential,\n  when_stake_pool: StakePoolHash,\n) -&gt; Fuzzer&lt;Voter&gt;\n Fuzzes either:\n - `ConstitutionalCommitteeMember`([`FromCredential`](#FromCredential))\n - `DelegateRepresentative`([`FromCredential`](#FromCredential))\n - `StakePool`([`StakePoolHash`](#StakePoolHash))","url":"test_kit/fuzzy/fuzzer.html#voter_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"datum_fuzzer","content":"datum_fuzzer(\n  when_datum_hash: Fuzzer&lt;(Data, DataHash)&gt;,\n  when_inline_datum: Fuzzer&lt;Data&gt;,\n) -&gt; Fuzzer&lt;transaction.Datum&gt;\n Fuzzes either `DatumHash`(`data_hash`) | `InlineDatum`(`data`) | `NoDatum`\n ```aiken\n // Fuzzes either:\n // - DatumHash(Any DataHash)\n // - InlineDatum(Any Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: data_hash_fuzzer(), when_inline_datum: data_fuzzer())\n \n // Fuzzes either:\n // - DatumHash(Known DataHash)\n // - InlineDatum(Any Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: (known_data, &quot;KNOWN_DATA_HASH&quot;) |&gt; fuzz.constant, when_inline_datum: data_fuzzer())\n \n // Fuzzes either:\n // - DatumHash(Any DataHash)\n // - InlineDatum(Known Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: data_hash_fuzzer(), when_inline_datum: known_data |&gt; fuzz.constant)\n \n // Fuzzes either:\n // - DatumHash(Known DataHash)\n // - InlineDatum(Known Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: (known_data, &quot;KNOWN_DATA_HASH&quot;) |&gt; fuzz.constant, when_inline_datum: known_data |&gt; fuzz.constant)\n ```\n See also:\n - [`data_hash_fuzzer`](#data_hash_fuzzer)`()`\n - [`data_fuzzer`](#data_fuzzer)`()`","url":"test_kit/fuzzy/fuzzer.html#datum_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"data_hash_fuzzer","content":"data_hash_fuzzer() -&gt; Fuzzer&lt;(Data, DataHash)&gt;\n Data Hash with Blake2b-256 hash digest (32 bytes) of some `data` fuzzer.\n\n Where,\n - `data` `&lt;-` [`data_fuzzer`](#data_fuzzer)`()`\n\n Could be used as `DatumHash` fuzzer, see: [`datum_fuzzer`](#datum_fuzzer)","url":"test_kit/fuzzy/fuzzer.html#data_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"data_fuzzer","content":"data_fuzzer() -&gt; Fuzzer&lt;Data&gt;\n Fuzzes either upcasted `Bool` | `Byte` | `ByteArray` | `Int`\n\n Where,\n |   Data                                                                     |   Possible Value    | Chance |\n |----------------------------------------------------------------------------|---------------------|--------|\n | [`Bool`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#bool)           |  `True` \\| `False`  |    25% |\n | [`Byte`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#byte)           |      `0`-`255`      |    25% |\n | [`ByteArray`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#bytearray) | `&quot;random 32 bytes&quot;` |    25% |\n | [`Int`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int)             |   `-255`-`16383`    |    25% |\n\n Could be used as `InlineDatum` fuzzer, see: [`datum_fuzzer`](#datum_fuzzer)","url":"test_kit/fuzzy/fuzzer.html#data_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"blake2b_224_fuzzer","content":"blake2b_224_fuzzer(\n  count: Int,\n) -&gt; Fuzzer&lt;List&lt;crypto.Hash&lt;Blake2b_224, ByteArray&gt;&gt;&gt;\n Blake2b-224 fuzzer with `n` unique count.","url":"test_kit/fuzzy/fuzzer.html#blake2b_224_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"blake2b_256_fuzzer","content":"blake2b_256_fuzzer(\n  count: Int,\n) -&gt; Fuzzer&lt;List&lt;crypto.Hash&lt;Blake2b_256, ByteArray&gt;&gt;&gt;\n Blake2b-256 fuzzer with `n` unique count.","url":"test_kit/fuzzy/fuzzer.html#blake2b_256_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"output_reference_fuzzer","content":"output_reference_fuzzer() -&gt; Fuzzer&lt;OutputReference&gt;\n Output Reference fuzzer,\n Transaction ID with 32 bytes,\n and output index between 0 and 512.","url":"test_kit/fuzzy/fuzzer.html#output_reference_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"transaction_id_fuzzer","content":"transaction_id_fuzzer() -&gt; Fuzzer&lt;TransactionId&gt;\n Transaction ID with 32 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#transaction_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_output_fuzzer","content":"user_output_fuzzer() -&gt; Fuzzer&lt;transaction.Output&gt;\n Simple wallet UTxO fuzzer,\n with a random number of tokens/NFTs.\n\n Fuzzes the following UTxO:\n ```aiken\n transaction.Output {\n   address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: NoDatum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#user_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_outputs_fuzzer","content":"user_outputs_fuzzer() -&gt; Fuzzer&lt;List&lt;transaction.Output&gt;&gt;\n Simple (non-script) outputs fuzzer.\n\n Fuzzes a list between 1-10 elements of the following UTxO:\n ```aiken\n transaction.Output {\n   address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: NoDatum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#user_outputs_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"specific_script_output_fuzzer","content":"specific_script_output_fuzzer(\n  script_hash: ScriptHash,\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;transaction.Output&gt;\n Given a script hash and datum,\n this fuzzer generates a UTxO at an address which its payment part is the same as the given script hash.\n\n Fuzzes the following UTxO:\n ```aiken\n transaction.Output {\n   address: from_script(script_hash),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: transaction.Datum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#specific_script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_output_fuzzer","content":"script_output_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Output)&gt;\n Returns a tuple where its first element is the random script hash (payment part of the UTxO&#39;s address).\n UTxO value is also random, with 2 ADA.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, utxo)\n ```\n Where,\n - `script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `utxo` `&lt;-` [`specific_script_output_fuzzer`](#specific_script_output_fuzzer)`(script_hash, datum)`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"authentic_script_output_fuzzer","content":"authentic_script_output_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Output)&gt;\n UTxO fuzzer, where the value is composed of 2 ADA and a Beacon NFT,\n such that its Policy ID is equal to the script credential of the payment part of UTxO&#39;s address.\n This script hash is also returned.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, utxo)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `utxo` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#authentic_script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_input_fuzzer","content":"user_input_fuzzer() -&gt; Fuzzer&lt;transaction.Input&gt;\n Simple wallet UTxO fuzzer,\n with a random reference output and a random number of tokens/NFTs.\n\n Fuzzes the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n   ```aiken\n   transaction.Output {\n     address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: NoDatum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#user_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_inputs_fuzzer","content":"user_inputs_fuzzer() -&gt; Fuzzer&lt;List&lt;transaction.Input&gt;&gt;\n Simple (non-script) inputs fuzzer.\n\n Fuzzes a list between 1-10 elements of the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n   ```aiken\n   transaction.Output {\n     address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: NoDatum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#user_inputs_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"specific_script_input_fuzzer","content":"specific_script_input_fuzzer(\n  script_hash: ScriptHash,\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;transaction.Input&gt;\n Similar to [`specific_script_output_fuzzer`](#specific_script_output_fuzzer),\n with an additional randomized wrapper for output reference.\n\n Fuzzes the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#specific_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_input_fuzzer","content":"script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input)&gt;\n Similar to [`script_output_fuzzer`](#script_output_fuzzer),\n with an additional randomized wrapper for output reference.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input)\n ```\n Where,\n - `script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`specific_script_output_fuzzer`](#specific_script_output_fuzzer)`(script_hash, datum)`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```","url":"test_kit/fuzzy/fuzzer.html#script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"authentic_script_input_fuzzer","content":"authentic_script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input)&gt;\n Similar to [`authentic_script_output_fuzzer`](#authentic_script_output_fuzzer),\n with and additional randomized wrapper for output reference.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```","url":"test_kit/fuzzy/fuzzer.html#authentic_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"inputs_with_an_authentic_script_input_fuzzer","content":"inputs_with_an_authentic_script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input, List&lt;transaction.Input&gt;)&gt;\n Fuzzer for a sorted list of user/wallet inputs,\n with the addition of one authentic script input.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input, sorted_inputs)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```\n - `wallet_inputs` `&lt;-` a list between 1-10 elements of `transaction.Input(output_reference, output)` where,\n     - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n     - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n       ```aiken\n       transaction.Output {\n         address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n         value: 2 or more ADA and 0-10 tokens/NFTs,\n         datum: NoDatum,\n         reference_script: None,\n       }\n       ```\n - `sorted_inputs` `=` `sorted_by_output_reference([script_input, ..wallet_inputs])`","url":"test_kit/fuzzy/fuzzer.html#inputs_with_an_authentic_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"CredentialHash","content":"CredentialHash {\n  Specified(crypto.Hash&lt;Blake2b_224, ByteArray&gt;)\n  Fuzzed\n}\n Alias: [`StakePoolHash`](#StakePoolHash)\nSpecified(crypto.Hash&lt;Blake2b_224, ByteArray&gt;)\n\nFuzzed\n","url":"test_kit/fuzzy/fuzzer.html#CredentialHash"},{"doc":"test_kit/fuzzy/fuzzer","title":"FromCredential","content":"FromCredential {\n  FromScript(CredentialHash)\n  FromKey(CredentialHash)\n  FromFuzzed\n}\n Used by:\n - [`address_fuzzer`](#address_fuzzer) to determine the payment part of a generated address\n - [`credential_fuzzer`](#credential_fuzzer) to determine the possible generated credential type\n - [`delegate_representative_fuzzer`](#delegate_representative_fuzzer) to determine the possible generated registered dRep credential type\nFromScript(CredentialHash)\n Payment part from script with known or any credential hash.\n Usage examples,\n ```aiken\n address_fuzzer(FromScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)), staking_part)\n address_fuzzer(FromScript(Fuzzed), staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.\nFromKey(CredentialHash)\n Payment part from key with known or any credential hash.\n Usage examples,\n ```aiken\n address_fuzzer(FromKey(Specified(&quot;KNOWN_KEY_HASH&quot;)), staking_part)\n address_fuzzer(FromKey(Fuzzed), staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.\nFromFuzzed\n Payment part from script or key with `Fuzzed` `CredentialHash`.\n Usage example,\n ```aiken\n address_fuzzer(FromFuzzed, staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.","url":"test_kit/fuzzy/fuzzer.html#FromCredential"},{"doc":"test_kit/fuzzy/fuzzer","title":"StakePoolHash","content":"StakePoolHash = CredentialHash\n\n","url":"test_kit/fuzzy/fuzzer.html#StakePoolHash"},{"doc":"test_kit/fuzzy/fuzzer","title":"VoteDelegateRepresentative","content":"VoteDelegateRepresentative {\n  VoteRegistered(FromCredential)\n  VoteAlwaysAbstain\n  VoteAlwaysNoConfidence\n  VoteFuzzed\n}\n Used by [`delegate_fuzzer`](#delegate_fuzzer) to determine the dRep type when the generated\n [`Delegate`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#Delegate) is either:\n - `DelegateVote`([`DelegateRepresentative`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#DelegateRepresentative))\n - `DelegateBoth`([`StakePoolId`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#StakePoolId),\n   [`DelegateRepresentative`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#DelegateRepresentative))\nVoteRegistered(FromCredential)\n\nVoteAlwaysAbstain\n\nVoteAlwaysNoConfidence\n\nVoteFuzzed\n","url":"test_kit/fuzzy/fuzzer.html#VoteDelegateRepresentative"},{"doc":"test_kit/fuzzy/fuzzer","title":"WithDelegation","content":"WithDelegation {\n  WithNoDelegation\n  WithDelegationScript(CredentialHash)\n  WithDelegationKey(CredentialHash)\n  WithTheSameDelegationScriptOrKey\n  WithFuzzedDelegation\n}\n Used by [`address_fuzzer`](#address_fuzzer) to determine the staking part of a generated address.\nWithNoDelegation\n Address generator with no staking part:\n ```aiken\n address_fuzzer(payment_part, WithNoDelegation)\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithDelegationScript(CredentialHash)\n Address generator with staking part from script with known or any credential hash:\n ```aiken\n address_fuzzer(payment_part, WithDelegationScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)))\n address_fuzzer(payment_part, WithDelegationScript(Fuzzed))\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithDelegationKey(CredentialHash)\n Address generator with staking part from key with known or any credential hash:\n ```aiken\n address_fuzzer(payment_part, WithDelegationKey(Specified(&quot;KNOWN_KEY_HASH&quot;)))\n address_fuzzer(payment_part, WithDelegationKey(Fuzzed))\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithTheSameDelegationScriptOrKey\n Address generator with staking part with the same credential as the payment part:\n ```aiken\n address_fuzzer(payment_part, WithTheSameDelegationScriptOrKey)\n ```\n\n Useful for generating multi-purpose validator addresses, because:\n - If the address payment credential is `Script`(`&quot;CURRENT_SCRIPT_HASH&quot;`), then `WithTheSameDelegationScriptOrKey`\n   will generate an address with delegation script hash `&quot;CURRENT_SCRIPT_HASH&quot;`\n - If the address payment credential is `VerificationKey`(`&quot;CURRENT_SCRIPT_HASH&quot;`), then `WithTheSameDelegationScriptOrKey`\n   will generate an address with delegation key hash `&quot;CURRENT_SCRIPT_HASH&quot;`\n\n ```aiken\n test multi_purpose_validator_addresses(multi_purpose_validator_address via address_fuzzer(FromScript(Fuzzed), WithTheSameDelegationScriptOrKey)) {\n   multi_purpose_validator_address |&gt; cbor.diagnostic |&gt; fuzz.label\n }\n ```\n\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithFuzzedDelegation\n Address generator with either `NoDelegation` | `Fuzzed` `DelegationScript` | `Fuzzed` `DelegationKey` | `TheSameDelegationScriptOrKey`\n staking part:\n ```aiken\n address_fuzzer(payment_part, WithFuzzedDelegation)\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.","url":"test_kit/fuzzy/fuzzer.html#WithDelegation"},{"doc":"test_kit/fuzzy/fuzzer","title":"test_kit/fuzzy/fuzzer","content":" Copied from [Anastasia-Labs/aiken-design-patterns](https://github.com/Anastasia-Labs/aiken-design-patterns/blob/main/lib/aiken-design-patterns/utils.ak)\n with a few additions that might be useful.","url":"test_kit/fuzzy/fuzzer.html"},{"doc":"test_kit/time","title":"add_time","content":"add_time(self: PosixTime, time: TimeUnit) -&gt; PosixTime\n Adds time to a [`PosixTime`](#PosixTime). For example:\n ```aiken\n 1234567890000\n   |&gt; add_time(Zero)\n // == 1234567890000 + 0\n \n 5443200000\n   |&gt; add_time(8 |&gt; Week)\n // == 5443200000 + 8 * 7 * 24 * 60 * 60 * 1_000\n \n 691200000\n   |&gt; add_time(7 |&gt; Day)\n // == 691200000 + 7 * 24 * 60 * 60 * 1_000\n \n 25200000\n   |&gt; add_time(6 |&gt; Minute)\n // == 25200000 + 6 * 60 * 1_000\n \n 360000\n   |&gt; add_time(3 |&gt; Second)\n // == 360000 + 3 * 1_000\n \n 5000\n   |&gt; add_time(2 |&gt; MS)\n // == 5000 + 2\n ```","url":"test_kit/time.html#add_time"},{"doc":"test_kit/time","title":"sub_time","content":"sub_time(self: PosixTime, time: TimeUnit) -&gt; PosixTime\n Subtracts time from a [`PosixTime`](#PosixTime). For example:\n ```aiken\n 1234567890000\n   |&gt; sub_time(Zero)\n // == 1234567890000 - 0\n \n 5443200000\n   |&gt; sub_time(8 |&gt; Week)\n // == 5443200000 - 8 * 7 * 24 * 60 * 60 * 1_000\n \n 691200000\n   |&gt; sub_time(7 |&gt; Day)\n // == 691200000 - 7 * 24 * 60 * 60 * 1_000\n \n 25200000\n   |&gt; sub_time(6 |&gt; Minute)\n // == 25200000 - 6 * 60 * 1_000\n \n 360000\n   |&gt; sub_time(3 |&gt; Second)\n // == 360000 - 3 * 1_000\n \n 5000\n   |&gt; sub_time(2 |&gt; MS)\n // == 5000 - 2\n ```","url":"test_kit/time.html#sub_time"},{"doc":"test_kit/time","title":"add_interval","content":"add_interval(\n  self: Interval,\n  lower_bound: TimeUnit,\n  upper_bound: TimeUnit,\n) -&gt; Interval\n Adds time to an `Interval`. For example:\n ```aiken\n interval.after(1234567890000)\n   |&gt; add_interval(lower_bound: Zero, upper_bound: Zero)\n // == interval.after(1234567890000 + 0)\n \n interval.after(5443200000)\n   |&gt; add_interval(Zero, 8 |&gt; Week)\n // == interval.after(5443200000 + 0)\n \n interval.after(691200000)\n   |&gt; add_interval(7 |&gt; Day, Zero)\n // == interval.after(691200000 + 7 * 24 * 60 * 60 * 1_000)\n \n interval.after(25200000)\n   |&gt; add_interval(6 |&gt; Minute, 5 |&gt; Hour)\n // == interval.after(25200000 + 6 * 60 * 1_000)\n \n interval.before(360000)\n   |&gt; add_interval(4 |&gt; DS, 3 |&gt; Second)\n // == interval.before(360000 + 3 * 1_000)\n \n interval.between(4, 5000)\n   |&gt; add_interval(2 |&gt; MS, 1 |&gt; CS)\n // == interval.between(4 + 2, 5000 + 1 * 10)\n ```","url":"test_kit/time.html#add_interval"},{"doc":"test_kit/time","title":"sub_interval","content":"sub_interval(\n  self: Interval,\n  lower_bound: TimeUnit,\n  upper_bound: TimeUnit,\n) -&gt; Interval\n Subtracts time from an `Interval`. For example:\n ```aiken\n interval.after(1234567890000)\n   |&gt; sub_interval(lower_bound: Zero, upper_bound: Zero)\n // == interval.after(1234567890000 - 0)\n \n interval.after(5443200000)\n   |&gt; sub_interval(Zero, 8 |&gt; Week)\n // == interval.after(5443200000 - 0)\n \n interval.after(691200000)\n   |&gt; sub_interval(7 |&gt; Day, Zero)\n // == interval.after(691200000 - 7 * 24 * 60 * 60 * 1_000)\n \n interval.after(25200000)\n   |&gt; sub_interval(6 |&gt; Minute, 5 |&gt; Hour)\n // == interval.after(25200000 - 6 * 60 * 1_000)\n \n interval.before(360000)\n   |&gt; sub_interval(4 |&gt; DS, 3 |&gt; Second)\n // == interval.before(360000 - 3 * 1_000)\n \n interval.between(4, 5000)\n   |&gt; sub_interval(2 |&gt; MS, 1 |&gt; CS)\n // == interval.between(4 - 2, 5000 - 1 * 10)\n ```","url":"test_kit/time.html#sub_interval"},{"doc":"test_kit/time","title":"add_bound","content":"add_bound(self: IntervalBound, bound: TimeUnit) -&gt; IntervalBound\n Adds time to an `IntervalBound`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound\n   |&gt; add_bound(Zero)\n // == IntervalBound { bound_type: Finite(1234567890000 + 0), is_inclusive: True }\n \n interval.after(5443200000).upper_bound\n   |&gt; add_bound(8 |&gt; Week)\n // == IntervalBound { bound_type: PositiveInfinity, is_inclusive: True }\n \n interval.before(691200000).lower_bound\n   |&gt; add_bound(7 |&gt; Day)\n // == IntervalBound { bound_type: NegativeInfinity, is_inclusive: True }\n \n interval.before(25200000).upper_bound\n   |&gt; add_bound(6 |&gt; Minute)\n // == IntervalBound { bound_type: Finite(25200000 + 6 * 60 * 1_000), is_inclusive: True }\n \n interval.between(360000, 12780000).lower_bound\n   |&gt; add_bound(3 |&gt; Second)\n // == IntervalBound { bound_type: Finite(360000 + 3 * 1_000), is_inclusive: True }\n \n interval.between(4, 5000).upper_bound\n   |&gt; add_bound(2 |&gt; MS)\n // == IntervalBound { bound_type: Finite(5000 + 2), is_inclusive: True }\n ```","url":"test_kit/time.html#add_bound"},{"doc":"test_kit/time","title":"sub_bound","content":"sub_bound(self: IntervalBound, bound: TimeUnit) -&gt; IntervalBound\n Subtracts time from an `IntervalBound`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound\n   |&gt; sub_bound(Zero)\n // == IntervalBound { bound_type: Finite(1234567890000 - 0), is_inclusive: True }\n \n interval.after(5443200000).upper_bound\n   |&gt; sub_bound(8 |&gt; Week)\n // == IntervalBound { bound_type: PositiveInfinity, is_inclusive: True }\n \n interval.before(691200000).lower_bound\n   |&gt; sub_bound(7 |&gt; Day)\n // == IntervalBound { bound_type: NegativeInfinity, is_inclusive: True }\n \n interval.before(25200000).upper_bound\n   |&gt; sub_bound(6 |&gt; Minute)\n // == IntervalBound { bound_type: Finite(25200000 - 6 * 60 * 1_000), is_inclusive: True }\n \n interval.between(360000, 12780000).lower_bound\n   |&gt; sub_bound(3 |&gt; Second)\n // == IntervalBound { bound_type: Finite(360000 - 3 * 1_000), is_inclusive: True }\n \n interval.between(4, 5000).upper_bound\n   |&gt; sub_bound(2 |&gt; MS)\n // == IntervalBound { bound_type: Finite(5000 - 2), is_inclusive: True }\n ```","url":"test_kit/time.html#sub_bound"},{"doc":"test_kit/time","title":"add_finite","content":"add_finite(self: IntervalBoundType, finite: TimeUnit) -&gt; IntervalBoundType\n Adds time to a [finite](https://aiken-lang.github.io/stdlib/aiken/interval.html#IntervalBoundType)\n `IntervalBoundType`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound.bound_type\n   |&gt; add_finite(Zero)\n // == Finite(1234567890000 + 0)\n \n interval.after(5443200000).upper_bound.bound_type\n   |&gt; add_finite(8 |&gt; Week)\n // == PositiveInfinity\n \n interval.before(691200000).lower_bound.bound_type\n   |&gt; add_finite(7 |&gt; Day)\n // == NegativeInfinity\n \n interval.before(25200000).upper_bound.bound_type\n   |&gt; add_finite(6 |&gt; Minute)\n // == Finite(25200000 + 6 * 60 * 1_000)\n \n interval.between(360000, 12780000).lower_bound.bound_type\n   |&gt; add_finite(3 |&gt; Second)\n // == Finite(360000 + 3 * 1_000)\n \n interval.between(4, 5000).upper_bound.bound_type\n   |&gt; add_finite(2 |&gt; MS)\n // == Finite(5000 + 2)\n ```","url":"test_kit/time.html#add_finite"},{"doc":"test_kit/time","title":"sub_finite","content":"sub_finite(self: IntervalBoundType, finite: TimeUnit) -&gt; IntervalBoundType\n Subtracts time from a [finite](https://aiken-lang.github.io/stdlib/aiken/interval.html#IntervalBoundType)\n `IntervalBoundType`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound.bound_type\n   |&gt; sub_finite(Zero)\n // == Finite(1234567890000 - 0)\n \n interval.after(5443200000).upper_bound.bound_type\n   |&gt; sub_finite(8 |&gt; Week)\n // == PositiveInfinity\n \n interval.before(691200000).lower_bound.bound_type\n   |&gt; sub_finite(7 |&gt; Day)\n // == NegativeInfinity\n \n interval.before(25200000).upper_bound.bound_type\n   |&gt; sub_finite(6 |&gt; Minute)\n // == Finite(25200000 - 6 * 60 * 1_000)\n \n interval.between(360000, 12780000).lower_bound.bound_type\n   |&gt; sub_finite(3 |&gt; Second)\n // == Finite(360000 - 3 * 1_000)\n \n interval.between(4, 5000).upper_bound.bound_type\n   |&gt; sub_finite(2 |&gt; MS)\n // == Finite(5000 - 2)\n ```","url":"test_kit/time.html#sub_finite"},{"doc":"test_kit/time","title":"PosixTime","content":"PosixTime = Int\n A number of milliseconds since 00:00:00 UTC on 1 January 1970.\n\n Brought back [`aiken/time.{PosixTime}`](https://github.com/aiken-lang/stdlib/blob/205e8f9a06c6f3c9e7c93bb7745e390515e2e2cf/lib/aiken/time.ak)\n after being removed in [`stdlib v2.0.0`](https://github.com/aiken-lang/stdlib/releases/tag/v2.0.0#:~:text=The%20module%20aiken/time.%20The%20PosixTime%20alias%20is%20no%20longer%20used%20anywhere)\n","url":"test_kit/time.html#PosixTime"},{"doc":"test_kit/time","title":"TimeUnit","content":"TimeUnit {\n  Zero\n  MS(Int)\n  CS(Int)\n  DS(Int)\n  Second(Int)\n  Minute(Int)\n  Hour(Int)\n  Day(Int)\n  Week(Int)\n}\n\nZero\n\nMS(Int)\n Millisecond: `1 millisecond = 1 / 1_000 second`\nCS(Int)\n Centisecond: `1 centisecond = 10 milliseconds`\nDS(Int)\n Decisecond: `1 decisecond = 100 milliseconds`\nSecond(Int)\n\nMinute(Int)\n\nHour(Int)\n\nDay(Int)\n\nWeek(Int)\n","url":"test_kit/time.html#TimeUnit"},{"doc":"test_kit/time","title":"test_kit/time","content":" You can have a real latest block-time value when running tests!\n\n &gt; [!NOTE]\n &gt; For Linux\n\n Copy [`./check.sh`](https://github.com/aiken-extra/test_kit/blob/main/check.sh)\n and paste it in the root directory of your Aiken project.\n Make it an executable.\n\n Add `now` to `aiken.toml` configurations like:\n\n ```toml\n [config.default]\n ...\n now = 0\n ...\n\n [config.any]\n ...\n now = 0\n ...\n ```\n\n Run `./check.sh` (with optional `-m` and/or `-E` arguments)\n\n ```bash\n $ ./check.sh -H\n Usage: ./check.sh -m &lt;MATCH_TEST&gt; -E &lt;ENV&gt;\n ```\n\n It will get the latest block-time, thanks to [Koios](https://www.koios.rest),\n and reconfigure the value for `now` in all environments.\n\n Access it from your code by:\n\n ```aiken\n use config\n trace config.now\n ```","url":"test_kit/time.html"}]);
\ No newline at end of file
+window.Aiken.initSearch([{"doc":"test_kit/fuzzy/fuzzer","title":"address_fuzzer","content":"address_fuzzer(\n  from: FromCredential,\n  with_delegation: WithDelegation,\n) -&gt; Fuzzer&lt;Address&gt;\n An [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address) fuzzer.\n See [`FromCredential`](#FromCredential) and [`WithDelegation`](#WithDelegation)\n for more information and usage examples.","url":"test_kit/fuzzy/fuzzer.html#address_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"credential_fuzzer","content":"credential_fuzzer(from: FromCredential) -&gt; Fuzzer&lt;address.Credential&gt;\n Fuzzes either `Script` or `VerificationKey` credentials determined by [`FromCredential`](#FromCredential)\n ```aiken\n credential_fuzzer(FromScript(Fuzzed))\n credential_fuzzer(FromKey(Fuzzed))\n credential_fuzzer(FromFuzzed)\n ```\n `FromScript` and `FromKey` with `Specified` [`CredentialHash`](#CredentialHash) are also supported\n but most of the time there&#39;s no reason to use a fuzzer for a known credential type and hash.","url":"test_kit/fuzzy/fuzzer.html#credential_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_hash_fuzzer","content":"script_hash_fuzzer() -&gt; Fuzzer&lt;ScriptHash&gt;\n Script Hash with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#script_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"verification_key_hash_fuzzer","content":"verification_key_hash_fuzzer() -&gt; Fuzzer&lt;VerificationKeyHash&gt;\n Verification Key Hash with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#verification_key_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"policy_id_fuzzer","content":"policy_id_fuzzer() -&gt; Fuzzer&lt;PolicyId&gt;\n Policy ID with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#policy_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"asset_name_fuzzer","content":"asset_name_fuzzer() -&gt; Fuzzer&lt;AssetName&gt;\n Asset Name with 0-32 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#asset_name_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"value_fuzzer","content":"value_fuzzer(min_lovelaces: assets.Lovelace) -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer,\n guaranteed to include some amount of ADA (minimum must be specified)\n\n Fuzzes a list of assets with some ADA with quantity of at least as the specified minimum amount, and 0-10 tokens:\n ```aiken\n assets.from_asset_list([\n   Pair(&quot;&quot;, [Pair(&quot;&quot;, lovelace_count)]),\n   ..,\n   Pair(policy_id, [Pair(token_name, quantity), ..])\n ])\n ```\n Where,\n - `lovelace_count` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(min_lovelaces)`\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"single_asset_value_fuzzer","content":"single_asset_value_fuzzer() -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer with a single asset.\n Randomly generates the Policy ID.\n\n Fuzzes the following token:\n ```aiken\n policy_id |&gt; assets.from_asset(token_name, quantity)\n ```\n Where,\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#single_asset_value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"single_specific_asset_value_fuzzer","content":"single_specific_asset_value_fuzzer(policy_id: PolicyId) -&gt; Fuzzer&lt;assets.Value&gt;\n A fuzzer for [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) with a single asset.\n Unsafely expects 28 bytes long Policy ID to be provided.\n\n Fuzzes the following token:\n ```aiken\n policy_id |&gt; assets.from_asset(token_name, quantity)\n ```\n Where,\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#single_specific_asset_value_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"mint_fuzzer","content":"mint_fuzzer() -&gt; Fuzzer&lt;assets.Value&gt;\n A [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value) fuzzer without any lovelaces.\n\n Fuzzes 1-10 tokens:\n ```aiken\n assets.from_asset_list([\n   Pair(policy_id, [Pair(token_name, quantity), ..])\n   ..,\n ])\n ```\n Where,\n - `policy_id` `&lt;-` [`policy_id_fuzzer`](#policy_id_fuzzer)`()`\n - `token_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `quantity` `&lt;-` [`fuzz.int_at_least`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int_at_least)`(1)`","url":"test_kit/fuzzy/fuzzer.html#mint_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"stake_pool_id_fuzzer","content":"stake_pool_id_fuzzer() -&gt; Fuzzer&lt;StakePoolId&gt;\n Stake Pool ID with 28 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#stake_pool_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"delegate_representative_fuzzer","content":"delegate_representative_fuzzer(\n  when_registered: FromCredential,\n) -&gt; Fuzzer&lt;DelegateRepresentative&gt;\n Fuzzes either `Registered`([`FromCredential`](#FromCredential)) | `AlwaysAbstain` | `AlwaysNoConfidence`\n ```aiken\n // Fuzzes either:\n // - Registered(&quot;KNOWN_SCRIPT_HASH&quot; |&gt; Script)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)))\n \n // Fuzzes either:\n // - Registered(Any Script)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromScript(Fuzzed))\n \n // Fuzzes either:\n // - Registered(&quot;KNOWN_KEY_HASH&quot; |&gt; VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromKey(Specified(&quot;KNOWN_KEY_HASH&quot;)))\n \n // Fuzzes either:\n // - Registered(Any VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromKey(Fuzzed))\n \n // Fuzzes either:\n // - Registered(Any Script or Any VerificationKey)\n // - AlwaysAbstain\n // - AlwaysNoConfidence\n delegate_representative_fuzzer(when_registered: FromFuzzed)\n ```","url":"test_kit/fuzzy/fuzzer.html#delegate_representative_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"delegate_fuzzer","content":"delegate_fuzzer(\n  when_block_production: StakePoolHash,\n  when_vote: VoteDelegateRepresentative,\n  when_both: (StakePoolHash, VoteDelegateRepresentative),\n) -&gt; Fuzzer&lt;certificate.Delegate&gt;\n Fuzzes either:\n - `DelegateBlockProduction`([`StakePoolHash`](#StakePoolHash))\n - `DelegateVote`([`VoteDelegateRepresentative`](#VoteDelegateRepresentative))\n - `DelegateBoth`([`StakePoolHash`](#StakePoolHash), [`VoteDelegateRepresentative`](#VoteDelegateRepresentative))","url":"test_kit/fuzzy/fuzzer.html#delegate_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"constitution_fuzzer","content":"constitution_fuzzer(some_guardrails: CredentialHash) -&gt; Fuzzer&lt;Constitution&gt;\n Fuzzes a [`Constitution`](https://aiken-lang.github.io/stdlib/cardano/governance.html#Constitution)\n with either `Some`(`&quot;KNOWN_SCRIPT_HASH&quot;` | `Any Script Hash`) or `None`\n ```aiken\n // Fuzzes either:\n // - Constitution(Some(&quot;KNOWN_SCRIPT_HASH&quot; |&gt; Script))\n // - Constitution(None)\n constitution_fuzzer(some_guardrails: Specified(&quot;KNOWN_SCRIPT_HASH&quot;))\n \n // Fuzzes either:\n // - Constitution(Some(Any Script Hash))\n // - Constitution(None)\n constitution_fuzzer(some_guardrails: Fuzzed)\n ```","url":"test_kit/fuzzy/fuzzer.html#constitution_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"governance_action_id_fuzzer","content":"governance_action_id_fuzzer() -&gt; Fuzzer&lt;GovernanceActionId&gt;\n Governance Action ID fuzzer,\n Transaction ID with 32 bytes,\n and output index between 0 and 512.","url":"test_kit/fuzzy/fuzzer.html#governance_action_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"vote_fuzzer","content":"vote_fuzzer() -&gt; Fuzzer&lt;Vote&gt;\n Fuzzes either `Yes` | `No` | `Abstain`","url":"test_kit/fuzzy/fuzzer.html#vote_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"voter_fuzzer","content":"voter_fuzzer(\n  when_constitutional_committee_member: FromCredential,\n  when_delegate_representative: FromCredential,\n  when_stake_pool: StakePoolHash,\n) -&gt; Fuzzer&lt;Voter&gt;\n Fuzzes either:\n - `ConstitutionalCommitteeMember`([`FromCredential`](#FromCredential))\n - `DelegateRepresentative`([`FromCredential`](#FromCredential))\n - `StakePool`([`StakePoolHash`](#StakePoolHash))","url":"test_kit/fuzzy/fuzzer.html#voter_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"datum_fuzzer","content":"datum_fuzzer(\n  when_datum_hash: Fuzzer&lt;(Data, DataHash)&gt;,\n  when_inline_datum: Fuzzer&lt;Data&gt;,\n) -&gt; Fuzzer&lt;transaction.Datum&gt;\n Fuzzes either `DatumHash`(`data_hash`) | `InlineDatum`(`data`) | `NoDatum`\n ```aiken\n // Fuzzes either:\n // - DatumHash(Any DataHash)\n // - InlineDatum(Any Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: data_hash_fuzzer(), when_inline_datum: data_fuzzer())\n \n // Fuzzes either:\n // - DatumHash(Known DataHash)\n // - InlineDatum(Any Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: (known_data, &quot;KNOWN_DATA_HASH&quot;) |&gt; fuzz.constant, when_inline_datum: data_fuzzer())\n \n // Fuzzes either:\n // - DatumHash(Any DataHash)\n // - InlineDatum(Known Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: data_hash_fuzzer(), when_inline_datum: known_data |&gt; fuzz.constant)\n \n // Fuzzes either:\n // - DatumHash(Known DataHash)\n // - InlineDatum(Known Data)\n // - NoDatum\n datum_fuzzer(when_datum_hash: (known_data, &quot;KNOWN_DATA_HASH&quot;) |&gt; fuzz.constant, when_inline_datum: known_data |&gt; fuzz.constant)\n ```\n See also:\n - [`data_hash_fuzzer`](#data_hash_fuzzer)`()`\n - [`data_fuzzer`](#data_fuzzer)`()`","url":"test_kit/fuzzy/fuzzer.html#datum_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"data_hash_fuzzer","content":"data_hash_fuzzer() -&gt; Fuzzer&lt;(Data, DataHash)&gt;\n Data Hash with Blake2b-256 hash digest (32 bytes) of some `data` fuzzer.\n\n Where,\n - `data` `&lt;-` [`data_fuzzer`](#data_fuzzer)`()`\n\n Could be used as `DatumHash` fuzzer, see: [`datum_fuzzer`](#datum_fuzzer)","url":"test_kit/fuzzy/fuzzer.html#data_hash_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"data_fuzzer","content":"data_fuzzer() -&gt; Fuzzer&lt;Data&gt;\n Fuzzes either upcasted `Bool` | `Byte` | `ByteArray` | `Int`\n\n Where,\n |   Data                                                                     |   Possible Value    | Chance |\n |----------------------------------------------------------------------------|---------------------|--------|\n | [`Bool`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#bool)           |  `True` \\| `False`  |    25% |\n | [`Byte`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#byte)           |      `0`-`255`      |    25% |\n | [`ByteArray`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#bytearray) | `&quot;random 32 bytes&quot;` |    25% |\n | [`Int`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#int)             |   `-255`-`16383`    |    25% |\n\n Could be used as `InlineDatum` fuzzer, see: [`datum_fuzzer`](#datum_fuzzer)","url":"test_kit/fuzzy/fuzzer.html#data_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"blake2b_224_fuzzer","content":"blake2b_224_fuzzer(\n  count: Int,\n) -&gt; Fuzzer&lt;List&lt;crypto.Hash&lt;Blake2b_224, ByteArray&gt;&gt;&gt;\n Blake2b-224 fuzzer with `n` unique count.","url":"test_kit/fuzzy/fuzzer.html#blake2b_224_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"blake2b_256_fuzzer","content":"blake2b_256_fuzzer(\n  count: Int,\n) -&gt; Fuzzer&lt;List&lt;crypto.Hash&lt;Blake2b_256, ByteArray&gt;&gt;&gt;\n Blake2b-256 fuzzer with `n` unique count.","url":"test_kit/fuzzy/fuzzer.html#blake2b_256_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"output_reference_fuzzer","content":"output_reference_fuzzer() -&gt; Fuzzer&lt;OutputReference&gt;\n Output Reference fuzzer,\n Transaction ID with 32 bytes,\n and output index between 0 and 512.","url":"test_kit/fuzzy/fuzzer.html#output_reference_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"transaction_id_fuzzer","content":"transaction_id_fuzzer() -&gt; Fuzzer&lt;TransactionId&gt;\n Transaction ID with 32 bytes fuzzer.","url":"test_kit/fuzzy/fuzzer.html#transaction_id_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_output_fuzzer","content":"user_output_fuzzer() -&gt; Fuzzer&lt;transaction.Output&gt;\n Simple wallet UTxO fuzzer,\n with a random number of tokens/NFTs.\n\n Fuzzes the following UTxO:\n ```aiken\n transaction.Output {\n   address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: NoDatum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#user_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_outputs_fuzzer","content":"user_outputs_fuzzer() -&gt; Fuzzer&lt;List&lt;transaction.Output&gt;&gt;\n Simple (non-script) outputs fuzzer.\n\n Fuzzes a list between 1-10 elements of the following UTxO:\n ```aiken\n transaction.Output {\n   address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: NoDatum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#user_outputs_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"specific_script_output_fuzzer","content":"specific_script_output_fuzzer(\n  script_hash: ScriptHash,\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;transaction.Output&gt;\n Given a script hash and datum,\n this fuzzer generates a UTxO at an address which its payment part is the same as the given script hash.\n\n Fuzzes the following UTxO:\n ```aiken\n transaction.Output {\n   address: from_script(script_hash),\n   value: 2 or more ADA and 0-10 tokens/NFTs,\n   datum: transaction.Datum,\n   reference_script: None,\n }\n ```","url":"test_kit/fuzzy/fuzzer.html#specific_script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_output_fuzzer","content":"script_output_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Output)&gt;\n Returns a tuple where its first element is the random script hash (payment part of the UTxO&#39;s address).\n UTxO value is also random, with 2 ADA.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, utxo)\n ```\n Where,\n - `script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `utxo` `&lt;-` [`specific_script_output_fuzzer`](#specific_script_output_fuzzer)`(script_hash, datum)`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"authentic_script_output_fuzzer","content":"authentic_script_output_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Output)&gt;\n UTxO fuzzer, where the value is composed of 2 ADA and a Beacon NFT,\n such that its Policy ID is equal to the script credential of the payment part of UTxO&#39;s address.\n This script hash is also returned.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, utxo)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `utxo` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#authentic_script_output_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_input_fuzzer","content":"user_input_fuzzer() -&gt; Fuzzer&lt;transaction.Input&gt;\n Simple wallet UTxO fuzzer,\n with a random reference output and a random number of tokens/NFTs.\n\n Fuzzes the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n   ```aiken\n   transaction.Output {\n     address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: NoDatum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#user_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"user_inputs_fuzzer","content":"user_inputs_fuzzer() -&gt; Fuzzer&lt;List&lt;transaction.Input&gt;&gt;\n Simple (non-script) inputs fuzzer.\n\n Fuzzes a list between 1-10 elements of the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n   ```aiken\n   transaction.Output {\n     address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: NoDatum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#user_inputs_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"specific_script_input_fuzzer","content":"specific_script_input_fuzzer(\n  script_hash: ScriptHash,\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;transaction.Input&gt;\n Similar to [`specific_script_output_fuzzer`](#specific_script_output_fuzzer),\n with an additional randomized wrapper for output reference.\n\n Fuzzes the following Transaction Input:\n ```aiken\n transaction.Input(output_reference, output)\n ```\n Where,\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```","url":"test_kit/fuzzy/fuzzer.html#specific_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"script_input_fuzzer","content":"script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input)&gt;\n Similar to [`script_output_fuzzer`](#script_output_fuzzer),\n with an additional randomized wrapper for output reference.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input)\n ```\n Where,\n - `script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `&lt;-` [`specific_script_output_fuzzer`](#specific_script_output_fuzzer)`(script_hash, datum)`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 or more ADA and 0-10 tokens/NFTs,\n     datum: transaction.Datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```","url":"test_kit/fuzzy/fuzzer.html#script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"authentic_script_input_fuzzer","content":"authentic_script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input)&gt;\n Similar to [`authentic_script_output_fuzzer`](#authentic_script_output_fuzzer),\n with and additional randomized wrapper for output reference.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```","url":"test_kit/fuzzy/fuzzer.html#authentic_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"inputs_with_an_authentic_script_input_fuzzer","content":"inputs_with_an_authentic_script_input_fuzzer(\n  datum: transaction.Datum,\n) -&gt; Fuzzer&lt;(ScriptHash, transaction.Input, List&lt;transaction.Input&gt;)&gt;\n Fuzzer for a sorted list of user/wallet inputs,\n with the addition of one authentic script input.\n\n Fuzzes the following tuple:\n ```aiken\n (script_hash, script_input, sorted_inputs)\n ```\n Where,\n - `policy_id: script_hash` `&lt;-` [`script_hash_fuzzer`](#script_hash_fuzzer)`()`\n - `asset_name` `&lt;-` [`asset_name_fuzzer`](#asset_name_fuzzer)`()`\n - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n - `output` `=`\n   ```aiken\n   transaction.Output {\n     address: from_script(script_hash),\n     value: 2 ADA and a Beacon NFT (policy_id: script_hash, asset_name, quantity: 1),\n     datum,\n     reference_script: None,\n   }\n   ```\n - `script_input` `=`\n   ```aiken\n   transaction.Input(output_reference, output)\n   ```\n - `wallet_inputs` `&lt;-` a list between 1-10 elements of `transaction.Input(output_reference, output)` where,\n     - `output_reference` `&lt;-` [`output_reference_fuzzer`](#output_reference_fuzzer)`()`\n     - `output` `&lt;-` [`user_output_fuzzer`](#user_output_fuzzer)`()`\n       ```aiken\n       transaction.Output {\n         address: Address(Fuzzed |&gt; FromKey, Fuzzed |&gt; WithDelegationKey),\n         value: 2 or more ADA and 0-10 tokens/NFTs,\n         datum: NoDatum,\n         reference_script: None,\n       }\n       ```\n - `sorted_inputs` `=` `sorted_by_output_reference([script_input, ..wallet_inputs])`","url":"test_kit/fuzzy/fuzzer.html#inputs_with_an_authentic_script_input_fuzzer"},{"doc":"test_kit/fuzzy/fuzzer","title":"CredentialHash","content":"CredentialHash {\n  Specified(crypto.Hash&lt;Blake2b_224, ByteArray&gt;)\n  Fuzzed\n}\n Alias: [`StakePoolHash`](#StakePoolHash)\nSpecified(crypto.Hash&lt;Blake2b_224, ByteArray&gt;)\n\nFuzzed\n","url":"test_kit/fuzzy/fuzzer.html#CredentialHash"},{"doc":"test_kit/fuzzy/fuzzer","title":"FromCredential","content":"FromCredential {\n  FromScript(CredentialHash)\n  FromKey(CredentialHash)\n  FromFuzzed\n}\n Used by:\n - [`address_fuzzer`](#address_fuzzer) to determine the payment part of a generated address\n - [`credential_fuzzer`](#credential_fuzzer) to determine the possible generated credential type\n - [`delegate_representative_fuzzer`](#delegate_representative_fuzzer) to determine the possible generated registered dRep credential type\nFromScript(CredentialHash)\n Payment part from script with known or any credential hash.\n Usage examples,\n ```aiken\n address_fuzzer(FromScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)), staking_part)\n address_fuzzer(FromScript(Fuzzed), staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.\nFromKey(CredentialHash)\n Payment part from key with known or any credential hash.\n Usage examples,\n ```aiken\n address_fuzzer(FromKey(Specified(&quot;KNOWN_KEY_HASH&quot;)), staking_part)\n address_fuzzer(FromKey(Fuzzed), staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.\nFromFuzzed\n Payment part from script or key with `Fuzzed` `CredentialHash`.\n Usage example,\n ```aiken\n address_fuzzer(FromFuzzed, staking_part)\n ```\n See [`WithDelegation`](#WithDelegation) for more info on how to set the rule for the staking part.","url":"test_kit/fuzzy/fuzzer.html#FromCredential"},{"doc":"test_kit/fuzzy/fuzzer","title":"StakePoolHash","content":"StakePoolHash = CredentialHash\n\n","url":"test_kit/fuzzy/fuzzer.html#StakePoolHash"},{"doc":"test_kit/fuzzy/fuzzer","title":"VoteDelegateRepresentative","content":"VoteDelegateRepresentative {\n  VoteRegistered(FromCredential)\n  VoteAlwaysAbstain\n  VoteAlwaysNoConfidence\n  VoteFuzzed\n}\n Used by [`delegate_fuzzer`](#delegate_fuzzer) to determine the dRep type when the generated\n [`Delegate`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#Delegate) is either:\n - `DelegateVote`([`DelegateRepresentative`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#DelegateRepresentative))\n - `DelegateBoth`([`StakePoolId`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#StakePoolId),\n   [`DelegateRepresentative`](https://aiken-lang.github.io/stdlib/cardano/certificate.html#DelegateRepresentative))\nVoteRegistered(FromCredential)\n\nVoteAlwaysAbstain\n\nVoteAlwaysNoConfidence\n\nVoteFuzzed\n","url":"test_kit/fuzzy/fuzzer.html#VoteDelegateRepresentative"},{"doc":"test_kit/fuzzy/fuzzer","title":"WithDelegation","content":"WithDelegation {\n  WithNoDelegation\n  WithDelegationScript(CredentialHash)\n  WithDelegationKey(CredentialHash)\n  WithTheSameDelegationScriptOrKey\n  WithFuzzedDelegation\n}\n Used by [`address_fuzzer`](#address_fuzzer) to determine the staking part of a generated address.\nWithNoDelegation\n Address generator with no staking part:\n ```aiken\n address_fuzzer(payment_part, WithNoDelegation)\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithDelegationScript(CredentialHash)\n Address generator with staking part from script with known or any credential hash:\n ```aiken\n address_fuzzer(payment_part, WithDelegationScript(Specified(&quot;KNOWN_SCRIPT_HASH&quot;)))\n address_fuzzer(payment_part, WithDelegationScript(Fuzzed))\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithDelegationKey(CredentialHash)\n Address generator with staking part from key with known or any credential hash:\n ```aiken\n address_fuzzer(payment_part, WithDelegationKey(Specified(&quot;KNOWN_KEY_HASH&quot;)))\n address_fuzzer(payment_part, WithDelegationKey(Fuzzed))\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithTheSameDelegationScriptOrKey\n Address generator with staking part with the same credential as the payment part:\n ```aiken\n address_fuzzer(payment_part, WithTheSameDelegationScriptOrKey)\n ```\n\n Useful for generating multi-purpose validator addresses, because:\n - If the address payment credential is `Script`(`&quot;CURRENT_SCRIPT_HASH&quot;`), then `WithTheSameDelegationScriptOrKey`\n   will generate an address with delegation script hash `&quot;CURRENT_SCRIPT_HASH&quot;`\n - If the address payment credential is `VerificationKey`(`&quot;CURRENT_SCRIPT_HASH&quot;`), then `WithTheSameDelegationScriptOrKey`\n   will generate an address with delegation key hash `&quot;CURRENT_SCRIPT_HASH&quot;`\n\n ```aiken\n test multi_purpose_validator_addresses(multi_purpose_validator_address via address_fuzzer(FromScript(Fuzzed), WithTheSameDelegationScriptOrKey)) {\n   multi_purpose_validator_address |&gt; cbor.diagnostic |&gt; fuzz.label\n }\n ```\n\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.\nWithFuzzedDelegation\n Address generator with either `NoDelegation` | `Fuzzed` `DelegationScript` | `Fuzzed` `DelegationKey` | `TheSameDelegationScriptOrKey`\n staking part:\n ```aiken\n address_fuzzer(payment_part, WithFuzzedDelegation)\n ```\n See [`FromCredential`](#FromCredential) for more info on how to set the rule for the payment part.","url":"test_kit/fuzzy/fuzzer.html#WithDelegation"},{"doc":"test_kit/fuzzy/fuzzer","title":"test_kit/fuzzy/fuzzer","content":" Copied from [Anastasia-Labs/aiken-design-patterns](https://github.com/Anastasia-Labs/aiken-design-patterns/blob/main/lib/aiken-design-patterns/utils.ak)\n with a few additions that might be useful.","url":"test_kit/fuzzy/fuzzer.html"},{"doc":"test_kit/tx","title":"set_id","content":"set_id(tx: Transaction, id: TransactionId) -&gt; Transaction\n Set `Transaction.id`.\n The default value is `#&quot;0000000000000000000000000000000000000000000000000000000000000000&quot;`","url":"test_kit/tx.html#set_id"},{"doc":"test_kit/tx","title":"set_validity_range","content":"set_validity_range(\n  tx: Transaction,\n  validity_range: ValidityRange,\n) -&gt; Transaction\n Set `Transaction.validity_range`.\n The default value is `interval.everything`","url":"test_kit/tx.html#set_validity_range"},{"doc":"test_kit/tx","title":"set_fee","content":"set_fee(tx: Transaction, fee: assets.Lovelace) -&gt; Transaction\n Set `Transaction.fee`.\n The default value is `0`","url":"test_kit/tx.html#set_fee"},{"doc":"test_kit/tx","title":"add_tx_input","content":"add_tx_input(tx: Transaction, tx_in: transaction.Input) -&gt; Transaction\n Concat `tx_in` to `Transaction.inputs`.\n The new `tx_in` is placed at the end of the list.\n\n Example,\n ```\n let tx_in = new_tx_input(...)\n     |&gt; set_datum_of_tx_input(...)\n     |&gt; attach_ref_script_to_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_input(tx_in)\n ```","url":"test_kit/tx.html#add_tx_input"},{"doc":"test_kit/tx","title":"new_tx_input","content":"new_tx_input(\n  output_reference: OutputReference,\n  address: Address,\n) -&gt; transaction.Input\n Initialize a transaction input with zero assets value, no datum, and no reference script.\n\n Example,\n ```\n let output_reference = OutputReference(#&quot;0000000000000000000000000000000000000000000000000000000000000064&quot;, 0)\n let address = from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n\n let tx_in = new_tx_input(output_reference, address)\n ```","url":"test_kit/tx.html#new_tx_input"},{"doc":"test_kit/tx","title":"with_asset_of_tx_input","content":"with_asset_of_tx_input(\n  input: transaction.Input,\n  asset: assets.Value,\n) -&gt; transaction.Input\n Add an asset to a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; with_asset_of_tx_input(from_lovelace(2_000_000))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId1&quot;, &quot;Nft1&quot;, 1))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId1&quot;, &quot;Token1&quot;, 3_000))\n     |&gt; with_asset_of_tx_input(from_asset(&quot;PolicyId2&quot;, &quot;Nft2&quot;, 1))\n ```","url":"test_kit/tx.html#with_asset_of_tx_input"},{"doc":"test_kit/tx","title":"set_datum_of_tx_input","content":"set_datum_of_tx_input(\n  input: transaction.Input,\n  datum: transaction.Datum,\n) -&gt; transaction.Input\n Set a datum of a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; set_datum_of_tx_input(InlineDatum(...))\n ```","url":"test_kit/tx.html#set_datum_of_tx_input"},{"doc":"test_kit/tx","title":"attach_ref_script_to_tx_input","content":"attach_ref_script_to_tx_input(\n  input: transaction.Input,\n  ref_script: ScriptHash,\n) -&gt; transaction.Input\n Attach a reference script to a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; attach_ref_script_to_tx_input(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n ```","url":"test_kit/tx.html#attach_ref_script_to_tx_input"},{"doc":"test_kit/tx","title":"remove_ref_script_from_tx_input","content":"remove_ref_script_from_tx_input(input: transaction.Input) -&gt; transaction.Input\n Remove reference script from a transaction input.\n\n Example,\n ```\n let tx_in = new_tx_input(output_reference, address)\n     |&gt; attach_ref_script_to_tx_input(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n     |&gt; remove_ref_script_from_tx_input()\n ```","url":"test_kit/tx.html#remove_ref_script_from_tx_input"},{"doc":"test_kit/tx","title":"add_tx_ref_input","content":"add_tx_ref_input(tx: Transaction, tx_ref_in: transaction.Input) -&gt; Transaction\n Concat `tx_ref_in` to `Transaction.reference_inputs`.\n The new `tx_ref_in` is placed at the end of the list.\n\n Example,\n ```\n let tx_ref_in = new_tx_input(...)\n     |&gt; set_datum_of_tx_input(...)\n     |&gt; attach_ref_script_to_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n     |&gt; with_asset_of_tx_input(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_ref_input(tx_ref_in)\n ```","url":"test_kit/tx.html#add_tx_ref_input"},{"doc":"test_kit/tx","title":"add_tx_output","content":"add_tx_output(tx: Transaction, tx_out: transaction.Output) -&gt; Transaction\n Concat `tx_out` to `Transaction.outputs`.\n The new `tx_out` is placed at the end of the list.\n\n Example,\n ```\n let tx_out = new_tx_output(...)\n     |&gt; set_datum_of_tx_output(...)\n     |&gt; attach_ref_script_to_tx_output(...)\n     |&gt; add_asset_to_tx_output(...)\n     |&gt; add_asset_to_tx_output(...)\n\n let txn = transaction.placeholder\n     |&gt; add_tx_output(tx_out)\n ```","url":"test_kit/tx.html#add_tx_output"},{"doc":"test_kit/tx","title":"new_tx_output","content":"new_tx_output(address: Address) -&gt; transaction.Output\n Initialize a transaction output with zero assets value, no datum, and no reference script.\n\n Example,\n ```\n let address = from_script(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n let tx_out = new_tx_output(address)\n ```","url":"test_kit/tx.html#new_tx_output"},{"doc":"test_kit/tx","title":"add_asset_to_tx_output","content":"add_asset_to_tx_output(\n  output: transaction.Output,\n  asset: assets.Value,\n) -&gt; transaction.Output\n Add an asset to a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; add_asset_to_tx_output(from_lovelace(2_000_000))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId1&quot;, &quot;Nft1&quot;, 1))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId1&quot;, &quot;Token1&quot;, 3_000))\n     |&gt; add_asset_to_tx_output(from_asset(&quot;PolicyId2&quot;, &quot;Nft2&quot;, 1))\n ```","url":"test_kit/tx.html#add_asset_to_tx_output"},{"doc":"test_kit/tx","title":"set_datum_of_tx_output","content":"set_datum_of_tx_output(\n  output: transaction.Output,\n  datum: transaction.Datum,\n) -&gt; transaction.Output\n Set a datum of a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; set_datum_of_tx_output(InlineDatum(...))\n ```","url":"test_kit/tx.html#set_datum_of_tx_output"},{"doc":"test_kit/tx","title":"attach_ref_script_to_tx_output","content":"attach_ref_script_to_tx_output(\n  output: transaction.Output,\n  ref_script: ScriptHash,\n) -&gt; transaction.Output\n Attach a reference script to a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; attach_ref_script_to_tx_output(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n ```","url":"test_kit/tx.html#attach_ref_script_to_tx_output"},{"doc":"test_kit/tx","title":"remove_ref_script_from_tx_output","content":"remove_ref_script_from_tx_output(\n  output: transaction.Output,\n) -&gt; transaction.Output\n Remove reference script from a transaction output.\n\n Example,\n ```\n let tx_out = new_tx_output(address)\n     |&gt; attach_ref_script_to_tx_output(#&quot;00000000000000000000000000000000000000000000000000000056&quot;)\n     |&gt; remove_ref_script_from_tx_output()\n ```","url":"test_kit/tx.html#remove_ref_script_from_tx_output"},{"doc":"test_kit/tx","title":"add_mint","content":"add_mint(tx: Transaction, asset: assets.Value) -&gt; Transaction\n Merge `asset` to `Transaction.mint`","url":"test_kit/tx.html#add_mint"},{"doc":"test_kit/tx","title":"add_certificate","content":"add_certificate(tx: Transaction, certificate: Certificate) -&gt; Transaction\n Concat `certificate` to `Transaction.certificates`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_certificate"},{"doc":"test_kit/tx","title":"add_withdrawal","content":"add_withdrawal(\n  tx: Transaction,\n  withdrawal_key: address.Credential,\n  withdrawal_value: assets.Lovelace,\n) -&gt; Transaction\n Merge `withdrawal` to `Transaction.withdrawals`","url":"test_kit/tx.html#add_withdrawal"},{"doc":"test_kit/tx","title":"add_signatory","content":"add_signatory(tx: Transaction, signatory: VerificationKeyHash) -&gt; Transaction\n Concat `signatory` to `Transaction.extra_signatories`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_signatory"},{"doc":"test_kit/tx","title":"add_datum","content":"add_datum(\n  tx: Transaction,\n  datum_key: DataHash,\n  datum_value: Data,\n) -&gt; Transaction\n Insert `datum` to `Transaction.datums`.\n If the key already exists, its value is overridden.","url":"test_kit/tx.html#add_datum"},{"doc":"test_kit/tx","title":"add_redeemer","content":"add_redeemer(\n  tx: Transaction,\n  redeemer_key: ScriptPurpose,\n  redeemer_value: transaction.Redeemer,\n) -&gt; Transaction\n Repsert `redeemer` to `Transaction.redeemers`.\n If the key already exists, its value is replaced.","url":"test_kit/tx.html#add_redeemer"},{"doc":"test_kit/tx","title":"add_vote","content":"add_vote(\n  tx: Transaction,\n  vote_key: governance.Voter,\n  vote_value: Pairs&lt;GovernanceActionId, governance.Vote&gt;,\n) -&gt; Transaction\n Repsert `vote` to `Transaction.votes`.\n If the key already exists, its value is replaced.","url":"test_kit/tx.html#add_vote"},{"doc":"test_kit/tx","title":"add_proposal_procedure","content":"add_proposal_procedure(\n  tx: Transaction,\n  deposit: assets.Lovelace,\n  return_address: address.Credential,\n  governance_action: GovernanceAction,\n) -&gt; Transaction\n Concat `proposal_procedure` to `Transaction.proposal_procedures`.\n The new value is placed at the end of the list.","url":"test_kit/tx.html#add_proposal_procedure"},{"doc":"test_kit/tx","title":"set_current_treasury_amount","content":"set_current_treasury_amount(\n  tx: Transaction,\n  amount: assets.Lovelace,\n) -&gt; Transaction\n Set `Transaction.current_treasury_amount`","url":"test_kit/tx.html#set_current_treasury_amount"},{"doc":"test_kit/tx","title":"unset_current_treasury_amount","content":"unset_current_treasury_amount(tx: Transaction) -&gt; Transaction\n Unset `Transaction.current_treasury_amount`","url":"test_kit/tx.html#unset_current_treasury_amount"},{"doc":"test_kit/tx","title":"set_treasury_donation","content":"set_treasury_donation(tx: Transaction, donation: assets.Lovelace) -&gt; Transaction\n Set `Transaction.treasury_donation`","url":"test_kit/tx.html#set_treasury_donation"},{"doc":"test_kit/tx","title":"unset_treasury_donation","content":"unset_treasury_donation(tx: Transaction) -&gt; Transaction\n Unset `Transaction.treasury_donation`","url":"test_kit/tx.html#unset_treasury_donation"},{"doc":"test_kit/tx","title":"test_kit/tx","content":" Usage example:\n ```\n test positive_case() {\n   // Arrange:\n   let nft = from_asset(&quot;NftPolicy&quot;, &quot;NftName&quot;, 1)\n   let token = from_asset(&quot;TokenPolicy&quot;, &quot;TokenName&quot;, 10)\n   // use cardano/assets.{from_asset}\n   let asset_1 = from_asset(&quot;AssetPolicy1&quot;, &quot;AssetName1&quot;, 1)\n   let asset_2 = from_asset(&quot;AssetPolicy2&quot;, &quot;AssetName2&quot;, 1000)\n   let asset_2_partial = from_asset(&quot;AssetPolicy2&quot;, &quot;AssetName2&quot;, 100)\n\n   // test_kit/tx:\n   let tx_ref_in =\n     new_tx_input(\n       output_reference: OutputReference(&quot;TxRefInHash&quot;, 0),\n       address: &quot;ScriptHash1&quot; |&gt; from_script,\n     )\n       |&gt; with_asset_of_tx_input(2_000_000 |&gt; from_lovelace)\n       |&gt; with_asset_of_tx_input(token)\n\n   let tx_in =\n     new_tx_input(\n       output_reference: OutputReference(&quot;TxInHash&quot;, 1),\n       address: &quot;ScriptHash2&quot; |&gt; from_script,\n     )\n       |&gt; set_datum_of_tx_input(&quot;OldDatum&quot; |&gt; InlineDatum)\n       |&gt; with_asset_of_tx_input(4_000_000 |&gt; from_lovelace)\n       |&gt; with_asset_of_tx_input(nft)\n       |&gt; with_asset_of_tx_input(asset_1)\n       |&gt; with_asset_of_tx_input(asset_2)\n\n   let tx_out =\n     new_tx_output(address: &quot;ScriptHash2&quot; |&gt; from_script)\n       |&gt; set_datum_of_tx_output(&quot;NewDatum&quot; |&gt; InlineDatum)\n       |&gt; add_asset_to_tx_output(4_000_000 |&gt; from_lovelace)\n       |&gt; add_asset_to_tx_output(nft)\n       |&gt; add_asset_to_tx_output(asset_1)\n       |&gt; add_asset_to_tx_output(asset_2_partial)\n\n   let tx =\n     transaction.placeholder\n       |&gt; add_tx_ref_input(tx_ref_in)\n       |&gt; add_tx_input(tx_in)\n       |&gt; add_tx_output(tx_out)\n       |&gt; add_signatory(&quot;VerificationKeyHash&quot;)\n\n   // use test_kit.{print}\n   print(&quot;Tx&quot;, tx)\n\n   // Assert:\n   validator.validate.spend(None, Void, output_reference, tx)\n }\n ```","url":"test_kit/tx.html"},{"doc":"test_kit/collections","title":"list_and","content":"list_and(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Tells whether all of the `booleans` are `true`","url":"test_kit/collections.html#list_and"},{"doc":"test_kit/collections","title":"list_or","content":"list_or(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Tells whether any of the `booleans` is `true`","url":"test_kit/collections.html#list_or"},{"doc":"test_kit/collections","title":"zip3","content":"zip3(az: List&lt;a&gt;, bz: List&lt;b&gt;, cz: List&lt;c&gt;) -&gt; List&lt;(a, b, c)&gt;\n Combine 3 lists together into a list of 3-tuple.","url":"test_kit/collections.html#zip3"},{"doc":"test_kit/collections","title":"unzip3","content":"unzip3(abc: List&lt;(a, b, c)&gt;) -&gt; (List&lt;a&gt;, List&lt;b&gt;, List&lt;c&gt;)\n Decompose a list of 3-tuple into a tuple of 3 lists.","url":"test_kit/collections.html#unzip3"},{"doc":"test_kit/collections","title":"test_kit/collections","content":"","url":"test_kit/collections.html"},{"doc":"test_kit/time/unwrap","title":"finite_start_of","content":"finite_start_of(interval: Interval) -&gt; PosixTime\n Returns the **normalized lower-bound** `Posixtime` of an `interval`\n &gt; [!WARNING]\n &gt; Will panic if `lower_bound` is not `Finite`","url":"test_kit/time/unwrap.html#finite_start_of"},{"doc":"test_kit/time/unwrap","title":"finite_end_of","content":"finite_end_of(interval: Interval) -&gt; PosixTime\n Returns the **normalized upper-bound** `PosixTime` of an `interval`\n &gt; [!WARNING]\n &gt; Will panic if `upper_bound` is not `Finite`","url":"test_kit/time/unwrap.html#finite_end_of"},{"doc":"test_kit/time/unwrap","title":"test_kit/time/unwrap","content":" A convenient way to unwrap `Finite(PosixTime)` from an `Interval`,\n but will **panic** if the interval bound is not `Finite`.","url":"test_kit/time/unwrap.html"},{"doc":"test_kit/time","title":"add_time","content":"add_time(self: PosixTime, time: TimeUnit) -&gt; PosixTime\n Adds time to a [`PosixTime`](#PosixTime). For example:\n ```aiken\n 1234567890000\n   |&gt; add_time(Zero)\n // == 1234567890000 + 0\n \n 5443200000\n   |&gt; add_time(8 |&gt; Week)\n // == 5443200000 + 8 * 7 * 24 * 60 * 60 * 1_000\n \n 691200000\n   |&gt; add_time(7 |&gt; Day)\n // == 691200000 + 7 * 24 * 60 * 60 * 1_000\n \n 25200000\n   |&gt; add_time(6 |&gt; Minute)\n // == 25200000 + 6 * 60 * 1_000\n \n 360000\n   |&gt; add_time(3 |&gt; Second)\n // == 360000 + 3 * 1_000\n \n 5000\n   |&gt; add_time(2 |&gt; MS)\n // == 5000 + 2\n ```","url":"test_kit/time.html#add_time"},{"doc":"test_kit/time","title":"sub_time","content":"sub_time(self: PosixTime, time: TimeUnit) -&gt; PosixTime\n Subtracts time from a [`PosixTime`](#PosixTime). For example:\n ```aiken\n 1234567890000\n   |&gt; sub_time(Zero)\n // == 1234567890000 - 0\n \n 5443200000\n   |&gt; sub_time(8 |&gt; Week)\n // == 5443200000 - 8 * 7 * 24 * 60 * 60 * 1_000\n \n 691200000\n   |&gt; sub_time(7 |&gt; Day)\n // == 691200000 - 7 * 24 * 60 * 60 * 1_000\n \n 25200000\n   |&gt; sub_time(6 |&gt; Minute)\n // == 25200000 - 6 * 60 * 1_000\n \n 360000\n   |&gt; sub_time(3 |&gt; Second)\n // == 360000 - 3 * 1_000\n \n 5000\n   |&gt; sub_time(2 |&gt; MS)\n // == 5000 - 2\n ```","url":"test_kit/time.html#sub_time"},{"doc":"test_kit/time","title":"add_interval","content":"add_interval(\n  self: Interval,\n  lower_bound: TimeUnit,\n  upper_bound: TimeUnit,\n) -&gt; Interval\n Adds time to an `Interval`. For example:\n ```aiken\n interval.after(1234567890000)\n   |&gt; add_interval(lower_bound: Zero, upper_bound: Zero)\n // == interval.after(1234567890000 + 0)\n \n interval.after(5443200000)\n   |&gt; add_interval(Zero, 8 |&gt; Week)\n // == interval.after(5443200000 + 0)\n \n interval.after(691200000)\n   |&gt; add_interval(7 |&gt; Day, Zero)\n // == interval.after(691200000 + 7 * 24 * 60 * 60 * 1_000)\n \n interval.after(25200000)\n   |&gt; add_interval(6 |&gt; Minute, 5 |&gt; Hour)\n // == interval.after(25200000 + 6 * 60 * 1_000)\n \n interval.before(360000)\n   |&gt; add_interval(4 |&gt; DS, 3 |&gt; Second)\n // == interval.before(360000 + 3 * 1_000)\n \n interval.between(4, 5000)\n   |&gt; add_interval(2 |&gt; MS, 1 |&gt; CS)\n // == interval.between(4 + 2, 5000 + 1 * 10)\n ```","url":"test_kit/time.html#add_interval"},{"doc":"test_kit/time","title":"sub_interval","content":"sub_interval(\n  self: Interval,\n  lower_bound: TimeUnit,\n  upper_bound: TimeUnit,\n) -&gt; Interval\n Subtracts time from an `Interval`. For example:\n ```aiken\n interval.after(1234567890000)\n   |&gt; sub_interval(lower_bound: Zero, upper_bound: Zero)\n // == interval.after(1234567890000 - 0)\n \n interval.after(5443200000)\n   |&gt; sub_interval(Zero, 8 |&gt; Week)\n // == interval.after(5443200000 - 0)\n \n interval.after(691200000)\n   |&gt; sub_interval(7 |&gt; Day, Zero)\n // == interval.after(691200000 - 7 * 24 * 60 * 60 * 1_000)\n \n interval.after(25200000)\n   |&gt; sub_interval(6 |&gt; Minute, 5 |&gt; Hour)\n // == interval.after(25200000 - 6 * 60 * 1_000)\n \n interval.before(360000)\n   |&gt; sub_interval(4 |&gt; DS, 3 |&gt; Second)\n // == interval.before(360000 - 3 * 1_000)\n \n interval.between(4, 5000)\n   |&gt; sub_interval(2 |&gt; MS, 1 |&gt; CS)\n // == interval.between(4 - 2, 5000 - 1 * 10)\n ```","url":"test_kit/time.html#sub_interval"},{"doc":"test_kit/time","title":"add_bound","content":"add_bound(self: IntervalBound, bound: TimeUnit) -&gt; IntervalBound\n Adds time to an `IntervalBound`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound\n   |&gt; add_bound(Zero)\n // == IntervalBound { bound_type: Finite(1234567890000 + 0), is_inclusive: True }\n \n interval.after(5443200000).upper_bound\n   |&gt; add_bound(8 |&gt; Week)\n // == IntervalBound { bound_type: PositiveInfinity, is_inclusive: True }\n \n interval.before(691200000).lower_bound\n   |&gt; add_bound(7 |&gt; Day)\n // == IntervalBound { bound_type: NegativeInfinity, is_inclusive: True }\n \n interval.before(25200000).upper_bound\n   |&gt; add_bound(6 |&gt; Minute)\n // == IntervalBound { bound_type: Finite(25200000 + 6 * 60 * 1_000), is_inclusive: True }\n \n interval.between(360000, 12780000).lower_bound\n   |&gt; add_bound(3 |&gt; Second)\n // == IntervalBound { bound_type: Finite(360000 + 3 * 1_000), is_inclusive: True }\n \n interval.between(4, 5000).upper_bound\n   |&gt; add_bound(2 |&gt; MS)\n // == IntervalBound { bound_type: Finite(5000 + 2), is_inclusive: True }\n ```","url":"test_kit/time.html#add_bound"},{"doc":"test_kit/time","title":"sub_bound","content":"sub_bound(self: IntervalBound, bound: TimeUnit) -&gt; IntervalBound\n Subtracts time from an `IntervalBound`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound\n   |&gt; sub_bound(Zero)\n // == IntervalBound { bound_type: Finite(1234567890000 - 0), is_inclusive: True }\n \n interval.after(5443200000).upper_bound\n   |&gt; sub_bound(8 |&gt; Week)\n // == IntervalBound { bound_type: PositiveInfinity, is_inclusive: True }\n \n interval.before(691200000).lower_bound\n   |&gt; sub_bound(7 |&gt; Day)\n // == IntervalBound { bound_type: NegativeInfinity, is_inclusive: True }\n \n interval.before(25200000).upper_bound\n   |&gt; sub_bound(6 |&gt; Minute)\n // == IntervalBound { bound_type: Finite(25200000 - 6 * 60 * 1_000), is_inclusive: True }\n \n interval.between(360000, 12780000).lower_bound\n   |&gt; sub_bound(3 |&gt; Second)\n // == IntervalBound { bound_type: Finite(360000 - 3 * 1_000), is_inclusive: True }\n \n interval.between(4, 5000).upper_bound\n   |&gt; sub_bound(2 |&gt; MS)\n // == IntervalBound { bound_type: Finite(5000 - 2), is_inclusive: True }\n ```","url":"test_kit/time.html#sub_bound"},{"doc":"test_kit/time","title":"add_finite","content":"add_finite(self: IntervalBoundType, finite: TimeUnit) -&gt; IntervalBoundType\n Adds time to a [finite](https://aiken-lang.github.io/stdlib/aiken/interval.html#IntervalBoundType)\n `IntervalBoundType`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound.bound_type\n   |&gt; add_finite(Zero)\n // == Finite(1234567890000 + 0)\n \n interval.after(5443200000).upper_bound.bound_type\n   |&gt; add_finite(8 |&gt; Week)\n // == PositiveInfinity\n \n interval.before(691200000).lower_bound.bound_type\n   |&gt; add_finite(7 |&gt; Day)\n // == NegativeInfinity\n \n interval.before(25200000).upper_bound.bound_type\n   |&gt; add_finite(6 |&gt; Minute)\n // == Finite(25200000 + 6 * 60 * 1_000)\n \n interval.between(360000, 12780000).lower_bound.bound_type\n   |&gt; add_finite(3 |&gt; Second)\n // == Finite(360000 + 3 * 1_000)\n \n interval.between(4, 5000).upper_bound.bound_type\n   |&gt; add_finite(2 |&gt; MS)\n // == Finite(5000 + 2)\n ```","url":"test_kit/time.html#add_finite"},{"doc":"test_kit/time","title":"sub_finite","content":"sub_finite(self: IntervalBoundType, finite: TimeUnit) -&gt; IntervalBoundType\n Subtracts time from a [finite](https://aiken-lang.github.io/stdlib/aiken/interval.html#IntervalBoundType)\n `IntervalBoundType`. For example:\n ```aiken\n interval.after(1234567890000).lower_bound.bound_type\n   |&gt; sub_finite(Zero)\n // == Finite(1234567890000 - 0)\n \n interval.after(5443200000).upper_bound.bound_type\n   |&gt; sub_finite(8 |&gt; Week)\n // == PositiveInfinity\n \n interval.before(691200000).lower_bound.bound_type\n   |&gt; sub_finite(7 |&gt; Day)\n // == NegativeInfinity\n \n interval.before(25200000).upper_bound.bound_type\n   |&gt; sub_finite(6 |&gt; Minute)\n // == Finite(25200000 - 6 * 60 * 1_000)\n \n interval.between(360000, 12780000).lower_bound.bound_type\n   |&gt; sub_finite(3 |&gt; Second)\n // == Finite(360000 - 3 * 1_000)\n \n interval.between(4, 5000).upper_bound.bound_type\n   |&gt; sub_finite(2 |&gt; MS)\n // == Finite(5000 - 2)\n ```","url":"test_kit/time.html#sub_finite"},{"doc":"test_kit/time","title":"PosixTime","content":"PosixTime = Int\n A number of milliseconds since 00:00:00 UTC on 1 January 1970.\n\n Brought back [`aiken/time.{PosixTime}`](https://github.com/aiken-lang/stdlib/blob/205e8f9a06c6f3c9e7c93bb7745e390515e2e2cf/lib/aiken/time.ak)\n after being removed in [`stdlib v2.0.0`](https://github.com/aiken-lang/stdlib/releases/tag/v2.0.0#:~:text=The%20module%20aiken/time.%20The%20PosixTime%20alias%20is%20no%20longer%20used%20anywhere)\n","url":"test_kit/time.html#PosixTime"},{"doc":"test_kit/time","title":"TimeUnit","content":"TimeUnit {\n  Zero\n  MS(Int)\n  CS(Int)\n  DS(Int)\n  Second(Int)\n  Minute(Int)\n  Hour(Int)\n  Day(Int)\n  Week(Int)\n}\n\nZero\n\nMS(Int)\n Millisecond: `1 millisecond = 1 / 1_000 second`\nCS(Int)\n Centisecond: `1 centisecond = 10 milliseconds`\nDS(Int)\n Decisecond: `1 decisecond = 100 milliseconds`\nSecond(Int)\n\nMinute(Int)\n\nHour(Int)\n\nDay(Int)\n\nWeek(Int)\n","url":"test_kit/time.html#TimeUnit"},{"doc":"test_kit/time","title":"test_kit/time","content":" You can have a real latest block-time value when running tests!\n\n &gt; [!NOTE]\n &gt; For Linux\n\n Copy [`./check.sh`](https://github.com/aiken-extra/test_kit/blob/main/check.sh)\n and paste it in the root directory of your Aiken project.\n Make it an executable.\n\n Add `now` to `aiken.toml` configurations like:\n\n ```toml\n [config.default]\n ...\n now = 0\n ...\n\n [config.any]\n ...\n now = 0\n ...\n ```\n\n Run `./check.sh` (with optional `-m` and/or `-E` arguments)\n\n ```bash\n $ ./check.sh -H\n Usage: ./check.sh -m &lt;MATCH_TEST&gt; -E &lt;ENV&gt;\n ```\n\n It will get the latest block-time, thanks to [Koios](https://www.koios.rest),\n and reconfigure the value for `now` in all environments.\n\n Access it from your code by:\n\n ```aiken\n use config\n trace config.now\n ```","url":"test_kit/time.html"},{"doc":"test_kit","title":"print","content":"print(label: ByteArray, data: Data) -&gt; Void\n Pretty-print data with label. This function calls\n [`fuzz.label`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#label)\n internally, so it will work with property testing.","url":"test_kit.html#print"},{"doc":"test_kit","title":"Any","content":"Any = Data\n\n","url":"test_kit.html#Any"},{"doc":"test_kit","title":"test_kit","content":"","url":"test_kit.html"},{"doc":"test_kit/collections/logic","title":"all_true","content":"all_true(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Equivalent to the old `list.and`","url":"test_kit/collections/logic.html#all_true"},{"doc":"test_kit/collections/logic","title":"any_true","content":"any_true(bool_list: List&lt;Bool&gt;) -&gt; Bool\n Equivalent to the old `list.or`","url":"test_kit/collections/logic.html#any_true"},{"doc":"test_kit/collections/logic","title":"all_false","content":"all_false(bool_list: List&lt;Bool&gt;) -&gt; Bool\n The opposite of `all_true`","url":"test_kit/collections/logic.html#all_false"},{"doc":"test_kit/collections/logic","title":"any_false","content":"any_false(bool_list: List&lt;Bool&gt;) -&gt; Bool\n The opposite of `any_true`","url":"test_kit/collections/logic.html#any_false"},{"doc":"test_kit/collections/logic","title":"test_kit/collections/logic","content":"","url":"test_kit/collections/logic.html"},{"doc":"test_kit/fuzzy","title":"tuple","content":"tuple(a: Fuzzer&lt;a&gt;, b: Fuzzer&lt;b&gt;) -&gt; Fuzzer&lt;(a, b)&gt;\n A convenient way of generating tuples instead of doing [`map2`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map2)\n ```aiken\n fuzz.map2(\n   fuzzer_a, fuzzer_b,\n   fn(a, b) { (a, b) }\n )\n ```","url":"test_kit/fuzzy.html#tuple"},{"doc":"test_kit/fuzzy","title":"tuple3","content":"tuple3(a: Fuzzer&lt;a&gt;, b: Fuzzer&lt;b&gt;, c: Fuzzer&lt;c&gt;) -&gt; Fuzzer&lt;(a, b, c)&gt;\n A convenient way of generating tuple3 instead of doing [`map3`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map3)\n ```aiken\n fuzz.map3(\n   fuzzer_a, fuzzer_b, fuzzer_c,\n   fn(a, b, c) { (a, b, c) }\n )\n ```","url":"test_kit/fuzzy.html#tuple3"},{"doc":"test_kit/fuzzy","title":"tuple4","content":"tuple4(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d)&gt;\n A convenient way of generating tuple4 instead of doing [`map4`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map4)\n ```aiken\n fuzz.map4(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d,\n   fn(a, b, c, d) { (a, b, c, d) }\n )\n ```","url":"test_kit/fuzzy.html#tuple4"},{"doc":"test_kit/fuzzy","title":"tuple5","content":"tuple5(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e)&gt;\n A convenient way of generating tuple5 instead of doing [`map5`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map5)\n ```aiken\n fuzz.map5(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e,\n   fn(a, b, c, d, e) { (a, b, c, d, e) }\n )\n ```","url":"test_kit/fuzzy.html#tuple5"},{"doc":"test_kit/fuzzy","title":"tuple6","content":"tuple6(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f)&gt;\n A convenient way of generating tuple6 instead of doing [`map6`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map6)\n ```aiken\n fuzz.map6(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f,\n   fn(a, b, c, d, e, f) { (a, b, c, d, e, f) }\n )\n ```","url":"test_kit/fuzzy.html#tuple6"},{"doc":"test_kit/fuzzy","title":"tuple7","content":"tuple7(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g)&gt;\n A convenient way of generating tuple7 instead of doing [`map7`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map7)\n ```aiken\n fuzz.map7(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g,\n   fn(a, b, c, d, e, f, g) { (a, b, c, d, e, f, g) }\n )\n ```","url":"test_kit/fuzzy.html#tuple7"},{"doc":"test_kit/fuzzy","title":"tuple8","content":"tuple8(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n  h: Fuzzer&lt;h&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g, h)&gt;\n A convenient way of generating tuple8 instead of doing [`map8`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map8)\n ```aiken\n fuzz.map8(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h,\n   fn(a, b, c, d, e, f, g, h) { (a, b, c, d, e, f, g, h) }\n )\n ```","url":"test_kit/fuzzy.html#tuple8"},{"doc":"test_kit/fuzzy","title":"tuple9","content":"tuple9(\n  a: Fuzzer&lt;a&gt;,\n  b: Fuzzer&lt;b&gt;,\n  c: Fuzzer&lt;c&gt;,\n  d: Fuzzer&lt;d&gt;,\n  e: Fuzzer&lt;e&gt;,\n  f: Fuzzer&lt;f&gt;,\n  g: Fuzzer&lt;g&gt;,\n  h: Fuzzer&lt;h&gt;,\n  i: Fuzzer&lt;i&gt;,\n) -&gt; Fuzzer&lt;(a, b, c, d, e, f, g, h, i)&gt;\n A convenient way of generating tuple9 instead of doing [`map9`](https://aiken-lang.github.io/fuzz/aiken/fuzz.html#map9)\n ```aiken\n fuzz.map9(\n   fuzzer_a, fuzzer_b, fuzzer_c, fuzzer_d, fuzzer_e, fuzzer_f, fuzzer_g, fuzzer_h, fuzzer_i,\n   fn(a, b, c, d, e, f, g, h, i) { (a, b, c, d, e, f, g, h, i) }\n )\n ```","url":"test_kit/fuzzy.html#tuple9"},{"doc":"test_kit/fuzzy","title":"unique","content":"unique(fuzzer: Fuzzer&lt;a&gt;, count: Int) -&gt; Fuzzer&lt;List&lt;a&gt;&gt;\n Generates a list of `n` unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique"},{"doc":"test_kit/fuzzy","title":"unique2","content":"unique2(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a)&gt;\n Generates a tuple of 2 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique2"},{"doc":"test_kit/fuzzy","title":"unique3","content":"unique3(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a)&gt;\n Generates a tuple of 3 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique3"},{"doc":"test_kit/fuzzy","title":"unique4","content":"unique4(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a)&gt;\n Generates a tuple of 4 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique4"},{"doc":"test_kit/fuzzy","title":"unique5","content":"unique5(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a)&gt;\n Generates a tuple of 5 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique5"},{"doc":"test_kit/fuzzy","title":"unique6","content":"unique6(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a)&gt;\n Generates a tuple of 6 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique6"},{"doc":"test_kit/fuzzy","title":"unique7","content":"unique7(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a)&gt;\n Generates a tuple of 7 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique7"},{"doc":"test_kit/fuzzy","title":"unique8","content":"unique8(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a, a)&gt;\n Generates a tuple of 8 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique8"},{"doc":"test_kit/fuzzy","title":"unique9","content":"unique9(fuzzer: Fuzzer&lt;a&gt;) -&gt; Fuzzer&lt;(a, a, a, a, a, a, a, a, a)&gt;\n Generates a tuple of 9 unique elements from the given fuzzer.","url":"test_kit/fuzzy.html#unique9"},{"doc":"test_kit/fuzzy","title":"test_kit/fuzzy","content":"","url":"test_kit/fuzzy.html"},{"doc":"config","title":"now","content":"now: Int = 1769000103000\n","url":"config.html#now"},{"doc":"config","title":"config","content":"","url":"config.html"},{"doc":"test_kit/tx/mock","title":"mock_hash","content":"mock_hash(from: Any, size: Int) -&gt; ByteArray\n Mocks any hash. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n The second parameter, `size: Int`, determines the byte length of the resulting mock hash.\n Smaller size than the length of the `from` argument will NOT truncate it,\n but 0 or negative size may cause panic or an unexpected behavior!\n\n Usage examples:\n ```aiken\n mock_hash(1, 2) == #&quot;0001&quot;\n mock_hash(345, 6) == #&quot;000000000345&quot;\n mock_hash(#&quot;af&quot;, 4) == #&quot;000000af&quot;\n mock_hash(&quot;Abc&quot;, 3) == #&quot;416263&quot;\n mock_hash(True, 5) == #&quot;0000D87A80&quot;\n mock_hash(None, 7) == #&quot;00000000D87A80&quot;\n mock_hash(Void, 1) == #&quot;D87980&quot;\n mock_hash(Never, 1) == #&quot;D87A80&quot;\n mock_hash(Never, 0) == #&quot;D87A80&quot;\n mock_hash([], 1) == #&quot;80&quot;\n mock_hash([], 0) == #&quot;80&quot;\n mock_hash([], -1) == #&quot;80&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash"},{"doc":"test_kit/tx/mock","title":"mock_hash_from_bytearray","content":"mock_hash_from_bytearray(bs: ByteArray, size: Int) -&gt; ByteArray\n Mocks any hash from [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray).\n\n The second parameter, `size: Int`, determines the byte length of the resulting mock hash.\n Smaller size than the length of the `from` argument will NOT truncate it.\n\n Usage examples:\n ```aiken\n mock_hash_from_bytearray(#&quot;af&quot;, 4) == #&quot;000000af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, 3) == #&quot;416263&quot;\n mock_hash_from_bytearray(#&quot;af&quot;, 2) == #&quot;00af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, 1) == #&quot;416263&quot;\n mock_hash_from_bytearray(#&quot;af&quot;, 0) == #&quot;af&quot;\n mock_hash_from_bytearray(&quot;Abc&quot;, -1) == #&quot;416263&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash_from_bytearray"},{"doc":"test_kit/tx/mock","title":"mock_hash_from_int","content":"mock_hash_from_int(i: Int, size: Int) -&gt; ByteArray\n Mocks any hash from [`Int`](https://aiken-lang.org/language-tour/primitive-types#int).\n\n &gt; [!IMPORTANT]\n &gt; NEGATIVE value for the first parameter is acceptable,\n &gt; but combined with 0 or less second argument value may\n &gt; cause panic or an unexpected behavior!\n\n Usage examples:\n ```aiken\n mock_hash_from_int(1, 2) == #&quot;0001&quot;\n mock_hash_from_int(345, 6) == #&quot;000000000345&quot;\n mock_hash_from_int(1, 0) == #&quot;01&quot;\n mock_hash_from_int(345, 0) == #&quot;0345&quot;\n mock_hash_from_int(1, -2) =&gt; 💥\n mock_hash_from_int(345, -6) =&gt; 💥\n mock_hash_from_int(-1, 2) == #&quot;9999&quot;\n mock_hash_from_int(-345, 6) == #&quot;999999999655&quot;\n ```","url":"test_kit/tx/mock.html#mock_hash_from_int"},{"doc":"test_kit/tx/mock","title":"mock_blake2b_224","content":"mock_blake2b_224(from: Any) -&gt; Hash&lt;Blake2b_224, ByteArray&gt;\n Mocks a Blake2b-224 Hash. It is 28-byte long.\n This function is not meant to be called directly,\n although there&#39;s no restriction.\n It is used by:\n - [`mock_verification_key_hash`](#mock_verification_key_hash)\n - [`mock_script_hash`](#mock_script_hash)\n - [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_blake2b_224"},{"doc":"test_kit/tx/mock","title":"mock_blake2b_256","content":"mock_blake2b_256(from: Any) -&gt; Hash&lt;Blake2b_256, ByteArray&gt;\n Mocks a Blake2b-256 Hash. It is 32-byte long.\n This function is not meant to be called directly,\n although there&#39;s no restriction.\n It is used by:\n - [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_blake2b_256"},{"doc":"test_kit/tx/mock","title":"mock_address","content":"mock_address(from_payment: Any, from_stake: Any) -&gt; Address\n Mocks an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n with `VerificationKey` payment and stake credentials.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_key = mock_address(123, False) // if 2nd arg is False | Void | [] | &quot;&quot; | 0, then there&#39;s no staking part\n address_key == from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n // use cardano/address.{from_verification_key, with_delegation_key}\n let address_key_key = mock_address(456, 789)\n address_key_key == (\n   from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n     |&gt; with_delegation_key(#&quot;00000000000000000000000000000000000000000000000000000789&quot;)\n )\n ```\n\n &gt; [!NOTE]\n &gt; `from_payment` and `from_stake` can have different data types. If `from_stake` is `False` | `Void` | `[]` | `&quot;&quot;` | `0`,\n &gt; then there&#39;s no staking part (`stake_credential: None`)","url":"test_kit/tx/mock.html#mock_address"},{"doc":"test_kit/tx/mock","title":"mock_script_address","content":"mock_script_address(from_payment: Any, from_stake: Any) -&gt; Address\n Similar to [`mock_address`](#mock_address), but with `Script` payment and stake credentials.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_script = mock_script_address(123, Void)\n address_script == from_script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n // use cardano/address.{from_script, with_delegation_script}\n let address_script_script = mock_script_address(456, 789)\n address_script_script == (\n   from_script(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n     |&gt; with_delegation_script(#&quot;00000000000000000000000000000000000000000000000000000789&quot;)\n )\n ```\n\n &gt; [!NOTE]\n &gt; `from_payment` and `from_stake` can have different data types. If `from_stake` is `False` | `Void` | `[]` | `&quot;&quot;` | `0`,\n &gt; then there&#39;s no staking part (`stake_credential: None`)","url":"test_kit/tx/mock.html#mock_script_address"},{"doc":"test_kit/tx/mock","title":"mock_address_with_delegation_script","content":"mock_address_with_delegation_script(\n  from_payment: Any,\n  from_stake: Any,\n) -&gt; Address\n Similar to [`mock_address`](#mock_address), but with `Script` stake credential,\n and the staking part (`stake_credential`) will NEVER be `None`.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_key_script = mock_address_with_delegation_script(123, 456)\n address_key_script == (\n   from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n     |&gt; with_delegation_script(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n )\n // use cardano/address.{from_verification_key, with_delegation_script}\n ```","url":"test_kit/tx/mock.html#mock_address_with_delegation_script"},{"doc":"test_kit/tx/mock","title":"mock_script_address_with_delegation_key","content":"mock_script_address_with_delegation_key(\n  from_payment: Any,\n  from_stake: Any,\n) -&gt; Address\n Similar to [`mock_address_with_delegation_script`](#mock_address_with_delegation_script),\n but it&#39;s the other way around. The payment part is `Script` credential, and the staking part is\n `VerificationKey` credential. The staking part (`stake_credential`) will NEVER be `None`.\n You can pass any serializable data type for both the `from_payment` and `from_stake` arguments.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n let address_script_key = mock_script_address_with_delegation_key(123, 456)\n address_script_key == (\n   from_script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n     |&gt; with_delegation_key(#&quot;00000000000000000000000000000000000000000000000000000456&quot;)\n )\n // use cardano/address.{from_script, with_delegation_key}\n ```","url":"test_kit/tx/mock.html#mock_script_address_with_delegation_key"},{"doc":"test_kit/tx/mock","title":"mock_address_from_verification_key","content":"mock_address_from_verification_key(from: Any) -&gt; Address\n Constructs an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n from a mock verification key hash. The resulting address has no delegation rights.\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_address_from_verification_key(1) == mock_address(1, 0)\n ```","url":"test_kit/tx/mock.html#mock_address_from_verification_key"},{"doc":"test_kit/tx/mock","title":"mock_address_from_script","content":"mock_address_from_script(from: Any) -&gt; Address\n Constructs an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n from a mock script hash. The address has no delegation rights.\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_address_from_script(2) == mock_script_address(2, 0)\n ```","url":"test_kit/tx/mock.html#mock_address_from_script"},{"doc":"test_kit/tx/mock","title":"with_mock_delegation_key","content":"with_mock_delegation_key(address: Address, from: Any) -&gt; Address\n Sets the delegation part of an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n using a mock verification key hash. This is useful when combined with [`mock_address_from_verification_key`](#mock_address_from_verification_key)\n or [`mock_address_from_script`](#mock_address_from_script). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n (mock_address_from_verification_key(3)\n   |&gt; with_mock_delegation_key(4)\n ) == mock_address(3, 4)\n \n (mock_address_from_script(3)\n   |&gt; with_mock_delegation_key(4)\n ) == mock_script_address_with_delegation_key(3, 4)\n ```","url":"test_kit/tx/mock.html#with_mock_delegation_key"},{"doc":"test_kit/tx/mock","title":"with_mock_delegation_script","content":"with_mock_delegation_script(address: Address, from: Any) -&gt; Address\n Sets the delegation part of an [`Address`](https://aiken-lang.github.io/stdlib/cardano/address.html#Address)\n using a mock script hash. This is useful when combined with [`mock_address_from_verification_key`](#mock_address_from_verification_key)\n or [`mock_address_from_script`](#mock_address_from_script). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n (mock_address_from_verification_key(5)\n   |&gt; with_mock_delegation_script(6)\n ) == mock_address_with_delegation_script(5, 6)\n \n (mock_address_from_script(5)\n   |&gt; with_mock_delegation_script(6)\n ) == mock_script_address(5, 6)\n ```","url":"test_kit/tx/mock.html#with_mock_delegation_script"},{"doc":"test_kit/tx/mock","title":"mock_verification_key_credential","content":"mock_verification_key_credential(from: Any) -&gt; Credential\n Mocks a `VerificationKey` credential. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_verification_key_credential(1) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n mock_verification_key_credential(123) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n mock_verification_key_credential(#&quot;af&quot;) == VerificationKey(#&quot;000000000000000000000000000000000000000000000000000000af&quot;)\n mock_verification_key_credential(&quot;Abc&quot;) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000416263&quot;)\n mock_verification_key_credential(True) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential(None) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential(Void) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87980&quot;)\n mock_verification_key_credential(Never) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_verification_key_credential([]) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000080&quot;)\n // use cardano/address.{VerificationKey}\n ```","url":"test_kit/tx/mock.html#mock_verification_key_credential"},{"doc":"test_kit/tx/mock","title":"mock_script_credential","content":"mock_script_credential(from: Any) -&gt; Credential\n Mocks a `Script` credential. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_script_credential(1) == Script(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n mock_script_credential(123) == Script(#&quot;00000000000000000000000000000000000000000000000000000123&quot;)\n mock_script_credential(#&quot;af&quot;) == Script(#&quot;000000000000000000000000000000000000000000000000000000af&quot;)\n mock_script_credential(&quot;Abc&quot;) == Script(#&quot;00000000000000000000000000000000000000000000000000416263&quot;)\n mock_script_credential(True) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential(None) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential(Void) == Script(#&quot;00000000000000000000000000000000000000000000000000D87980&quot;)\n mock_script_credential(Never) == Script(#&quot;00000000000000000000000000000000000000000000000000D87A80&quot;)\n mock_script_credential([]) == Script(#&quot;00000000000000000000000000000000000000000000000000000080&quot;)\n // use cardano/address.{Script}\n ```","url":"test_kit/tx/mock.html#mock_script_credential"},{"doc":"test_kit/tx/mock","title":"mock_verification_key_hash","content":"mock_verification_key_hash(from: Any) -&gt; VerificationKeyHash\n Mocks a [`VerificationKeyHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#VerificationKeyHash).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_verification_key_hash(1) == #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n mock_verification_key_hash(123) == #&quot;00000000000000000000000000000000000000000000000000000123&quot;\n mock_verification_key_hash(#&quot;af&quot;) == #&quot;000000000000000000000000000000000000000000000000000000af&quot;\n mock_verification_key_hash(&quot;Abc&quot;) == #&quot;00000000000000000000000000000000000000000000000000416263&quot;\n mock_verification_key_hash(True) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash(None) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash(Void) == #&quot;00000000000000000000000000000000000000000000000000D87980&quot;\n mock_verification_key_hash(Never) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_verification_key_hash([]) == #&quot;00000000000000000000000000000000000000000000000000000080&quot;\n ```\n \n Alias: [`mock_vkh`](#mock_vkh)","url":"test_kit/tx/mock.html#mock_verification_key_hash"},{"doc":"test_kit/tx/mock","title":"mock_vkh","content":"mock_vkh(from: Any) -&gt; VerificationKeyHash\n See: [`mock_verification_key_hash`](#mock_verification_key_hash)","url":"test_kit/tx/mock.html#mock_vkh"},{"doc":"test_kit/tx/mock","title":"mock_script_hash","content":"mock_script_hash(from: Any) -&gt; ScriptHash\n Mocks a [`ScriptHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#ScriptHash).\n Under the hood, it&#39;s the same as [`mock_verification_key_hash`](#mock_verification_key_hash)\n or [`mock_vkh`](#mock_vkh). You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage examples:\n ```aiken\n mock_script_hash(1) == #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n mock_script_hash(123) == #&quot;00000000000000000000000000000000000000000000000000000123&quot;\n mock_script_hash(#&quot;af&quot;) == #&quot;000000000000000000000000000000000000000000000000000000af&quot;\n mock_script_hash(&quot;Abc&quot;) == #&quot;00000000000000000000000000000000000000000000000000416263&quot;\n mock_script_hash(True) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash(None) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash(Void) == #&quot;00000000000000000000000000000000000000000000000000D87980&quot;\n mock_script_hash(Never) == #&quot;00000000000000000000000000000000000000000000000000D87A80&quot;\n mock_script_hash([]) == #&quot;00000000000000000000000000000000000000000000000000000080&quot;\n ```\n \n Alias: [`mock_sh`](#mock_sh)","url":"test_kit/tx/mock.html#mock_script_hash"},{"doc":"test_kit/tx/mock","title":"mock_sh","content":"mock_sh(from: Any) -&gt; ScriptHash\n See: [`mock_script_hash`](#mock_script_hash)","url":"test_kit/tx/mock.html#mock_sh"},{"doc":"test_kit/tx/mock","title":"mock_asset","content":"mock_asset(from: Any, asset_name: AssetName, quantity: Int) -&gt; Value\n Constructs a [`Value`](https://aiken-lang.github.io/stdlib/cardano/assets.html#Value)\n from a mock [`PolicyId`](#mock_policy_id), [`AssetName`](https://aiken-lang.github.io/stdlib/cardano/assets.html#AssetName)\n and a given `quantity`. You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_asset(&quot;PolicyId&quot;, &quot;NFT&quot;, 1)\n   |&gt; add(#&quot;0000000000000000000000000000000000000000506F6C6963794964&quot;, &quot;NFT&quot;, -1)\n   |&gt; is_zero() // True\n // use cardano/assets.{add, is_zero}\n ```\n\n &gt; [!NOTE]\n &gt; You can also only mock the Policy ID, see: [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_asset"},{"doc":"test_kit/tx/mock","title":"mock_policy_id","content":"mock_policy_id(from: Any) -&gt; PolicyId\n Mocks a [`PolicyId`](https://aiken-lang.github.io/stdlib/cardano/assets.html#PolicyId).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n from_asset(mock_policy_id(123), &quot;NFT&quot;, 1)\n   |&gt; add(#&quot;00000000000000000000000000000000000000000000000000000123&quot;, &quot;NFT&quot;, -1)\n   |&gt; is_zero() // True\n // use cardano/assets.{from_asset, add, is_zero}\n ```\n \n Alias: [`mock_policy`](#mock_policy)","url":"test_kit/tx/mock.html#mock_policy_id"},{"doc":"test_kit/tx/mock","title":"mock_policy","content":"mock_policy(from: Any) -&gt; PolicyId\n See: [`mock_policy_id`](#mock_policy_id)","url":"test_kit/tx/mock.html#mock_policy"},{"doc":"test_kit/tx/mock","title":"mock_output_reference","content":"mock_output_reference(from: Any, output_index: Int) -&gt; OutputReference\n Mocks an [`OutputReference`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#OutputReference).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n mock_output_reference(123, 45) == OutputReference {\n   transaction_id: #&quot;0000000000000000000000000000000000000000000000000000000000000123&quot;,\n   output_index: 45,\n }\n // use cardano/transaction.{OutputReference}\n ```\n\n Aliases:\n - [`mock_out_ref`](#mock_out_ref)\n - [`mock_o_ref`](#mock_o_ref)\n\n &gt; [!NOTE]\n &gt; You can also only mock the Transaction ID, see: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_output_reference"},{"doc":"test_kit/tx/mock","title":"mock_out_ref","content":"mock_out_ref(from: Any, output_index: Int) -&gt; OutputReference\n See: [`mock_output_reference`](#mock_output_reference)","url":"test_kit/tx/mock.html#mock_out_ref"},{"doc":"test_kit/tx/mock","title":"mock_o_ref","content":"mock_o_ref(from: Any, output_index: Int) -&gt; OutputReference\n See: [`mock_output_reference`](#mock_output_reference)","url":"test_kit/tx/mock.html#mock_o_ref"},{"doc":"test_kit/tx/mock","title":"mock_transaction_id","content":"mock_transaction_id(from: Any) -&gt; TransactionId\n Mocks a [`TransactionId`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#TransactionId).\n You can pass any serializable data type for the `from` argument.\n\n If the argument data type is [`Int`](https://aiken-lang.org/language-tour/primitive-types#int),\n then it will be processed like: `123` =&gt; `#&quot;00..0123&quot;`.\n\n If the argument data type is [`ByteArray`](https://aiken-lang.org/language-tour/primitive-types#bytearray),\n then it will be processed like: `&quot;Abc&quot;` =&gt; `#&quot;00..00416263&quot;`, `#&quot;af&quot;` =&gt; `#&quot;00..000000af&quot;`.\n\n Otherwise, it will be [serialised](https://aiken-lang.github.io/stdlib/aiken/cbor.html#serialise).\n\n Usage example:\n ```aiken\n OutputReference(mock_transaction_id(1), 0) == mock_output_reference(1, 0)\n // use cardano/transaction.{OutputReference}\n ```\n \n Aliases:\n - [`mock_tran_id`](#mock_tran_id)\n - [`mock_txn_id`](#mock_txn_id)\n - [`mock_tx_id`](#mock_tx_id)\n - [`mock_tx_hash`](#mock_tx_hash)\n - [`mock_txn_hash`](#mock_txn_hash)\n - [`mock_tran_hash`](#mock_tran_hash)\n - [`mock_transaction_hash`](#mock_transaction_hash)","url":"test_kit/tx/mock.html#mock_transaction_id"},{"doc":"test_kit/tx/mock","title":"mock_tran_id","content":"mock_tran_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tran_id"},{"doc":"test_kit/tx/mock","title":"mock_txn_id","content":"mock_txn_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_txn_id"},{"doc":"test_kit/tx/mock","title":"mock_tx_id","content":"mock_tx_id(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tx_id"},{"doc":"test_kit/tx/mock","title":"mock_tx_hash","content":"mock_tx_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tx_hash"},{"doc":"test_kit/tx/mock","title":"mock_txn_hash","content":"mock_txn_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_txn_hash"},{"doc":"test_kit/tx/mock","title":"mock_tran_hash","content":"mock_tran_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_tran_hash"},{"doc":"test_kit/tx/mock","title":"mock_transaction_hash","content":"mock_transaction_hash(from: Any) -&gt; TransactionId\n See: [`mock_transaction_id`](#mock_transaction_id)","url":"test_kit/tx/mock.html#mock_transaction_hash"},{"doc":"test_kit/tx/mock","title":"test_kit/tx/mock","content":" A fancy way to construct mock hashes, such as:\n - [`VerificationKeyHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#VerificationKeyHash)\n - [`ScriptHash`](https://aiken-lang.github.io/stdlib/aiken/crypto.html#ScriptHash)\n - [`PolicyId`](https://aiken-lang.github.io/stdlib/cardano/assets.html#PolicyId)\n - [`TransactionId`](https://aiken-lang.github.io/stdlib/cardano/transaction.html#TransactionId)\n - and any other hashes\n\n Usage examples:\n ```aiken\n // Mock Address:\n let address_key = mock_address(1, False) // if 2nd arg is False | Void | [] | &quot;&quot; | 0, then there&#39;s no staking part\n address_key == from_verification_key(#&quot;00000000000000000000000000000000000000000000000000000001&quot;)\n // use cardano/address.{from_verification_key}\n\n // Mock Credential:\n mock_verification_key_credential(2) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000002&quot;)\n mock_script_credential(3) == Script(#&quot;00000000000000000000000000000000000000000000000000000003&quot;)\n // use cardano/address.{VerificationKey, Script}\n (mock_verification_key_hash(4) |&gt; VerificationKey) == VerificationKey(#&quot;00000000000000000000000000000000000000000000000000000004&quot;)\n (mock_script_hash(5) |&gt; Script) == Script(#&quot;00000000000000000000000000000000000000000000000000000005&quot;)\n \n // Mock Asset:\n let mint = mock_asset(6, &quot;NFT&quot;, 1)\n let burn = from_asset(mock_policy_id(6), &quot;NFT&quot;, -1) // you can also only mock the Policy ID\n mint\n   |&gt; merge(burn)\n   |&gt; is_zero() // True\n // use cardano/assets.{from_asset, merge, is_zero}\n \n // Mock Output Reference:\n let o_ref = mock_output_reference(7, 0) // aliases: mock_out_ref, mock_o_ref\n and {\n   o_ref == OutputReference(mock_transaction_id(7), 0), // you can also only mock the Transaction ID\n   o_ref == OutputReference {\n     transaction_id: #&quot;0000000000000000000000000000000000000000000000000000000000000007&quot;,\n     output_index: 0,\n   },\n }\n // use cardano/transaction.{OutputReference}\n \n // Mock any hash:\n mock_hash(8, 2) == #&quot;0008&quot;\n mock_hash_from_int(9, 3) == #&quot;000009&quot;\n mock_hash_from_bytearray(#&quot;10&quot;, 4) == #&quot;00000010&quot;\n ```\n\n &gt; [!NOTE]\n &gt; Constructing mock hashes this way will add to your Memory and CPU Usages **during testing**!\n &gt; For example: `mock_sh(1)` will generate `#&quot;00000000000000000000000000000000000000000000000000000001&quot;`,\n &gt; but notice the following Memory and CPU Usages.\n &gt; ```aiken\n &gt; /// Aiken v1.1.9 mem: 261806, cpu: 75093536\n &gt; test mock() {\n &gt;   trace mock_sh(1)\n &gt;   True\n &gt; }\n &gt; \n &gt; /// Aiken v1.1.9 mem: 254825, cpu: 71651198\n &gt; test no_mock() {\n &gt;   trace #&quot;00000000000000000000000000000000000000000000000000000001&quot;\n &gt;   True\n &gt; }\n &gt; ```","url":"test_kit/tx/mock.html"}]);
\ No newline at end of file
diff --git a/docs/test_kit.html b/docs/test_kit.html
index 49b2a60..8164dca 100644
--- a/docs/test_kit.html
+++ b/docs/test_kit.html
@@ -482,9 +482,9 @@ <h2 id="print"><pre class="hljs language-aiken">print(label: ByteArray, data: Da
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="./js/lunr.min.js?v=1.1.21"></script>
-    <script src="./js/index.js?v=1768998915"></script>
+    <script src="./js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="./search-data.js?v=1768998915"></script>
+    <script src="./search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/collections.html b/docs/test_kit/collections.html
index 48a4906..1e02c0e 100644
--- a/docs/test_kit/collections.html
+++ b/docs/test_kit/collections.html
@@ -516,9 +516,9 @@ <h2 id="unzip3"><pre class="hljs language-aiken">unzip3(abc: List&lt;(a, b, c)&g
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../js/index.js?v=1768998915"></script>
+    <script src="../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../search-data.js?v=1768998915"></script>
+    <script src="../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/collections/logic.html b/docs/test_kit/collections/logic.html
index f9868f8..ee090f4 100644
--- a/docs/test_kit/collections/logic.html
+++ b/docs/test_kit/collections/logic.html
@@ -496,9 +496,9 @@ <h2 id="any_false"><pre class="hljs language-aiken">any_false(bool_list: List&lt
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../../js/index.js?v=1768998915"></script>
+    <script src="../../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../../search-data.js?v=1768998915"></script>
+    <script src="../../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/fuzzy.html b/docs/test_kit/fuzzy.html
index 976c9b2..8d67073 100644
--- a/docs/test_kit/fuzzy.html
+++ b/docs/test_kit/fuzzy.html
@@ -835,9 +835,9 @@ <h2 id="unique9"><pre class="hljs language-aiken">unique9(fuzzer: Fuzzer&lt;a&gt
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../js/index.js?v=1768998915"></script>
+    <script src="../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../search-data.js?v=1768998915"></script>
+    <script src="../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/fuzzy/fuzzer.html b/docs/test_kit/fuzzy/fuzzer.html
index 6b0b6f3..0900065 100644
--- a/docs/test_kit/fuzzy/fuzzer.html
+++ b/docs/test_kit/fuzzy/fuzzer.html
@@ -1862,9 +1862,9 @@ <h2 id="inputs_with_an_authentic_script_input_fuzzer"><pre class="hljs language-
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../../js/index.js?v=1768998915"></script>
+    <script src="../../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../../search-data.js?v=1768998915"></script>
+    <script src="../../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/time.html b/docs/test_kit/time.html
index 55abc9f..1f89048 100644
--- a/docs/test_kit/time.html
+++ b/docs/test_kit/time.html
@@ -990,9 +990,9 @@ <h2 id="sub_finite"><pre class="hljs language-aiken">sub_finite(self: IntervalBo
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../js/index.js?v=1768998915"></script>
+    <script src="../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../search-data.js?v=1768998915"></script>
+    <script src="../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/time/unwrap.html b/docs/test_kit/time/unwrap.html
index ffdb2a1..dd7875a 100644
--- a/docs/test_kit/time/unwrap.html
+++ b/docs/test_kit/time/unwrap.html
@@ -468,9 +468,9 @@ <h2 id="finite_end_of"><pre class="hljs language-aiken">finite_end_of(interval:
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../../js/index.js?v=1768998915"></script>
+    <script src="../../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../../search-data.js?v=1768998915"></script>
+    <script src="../../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/tx.html b/docs/test_kit/tx.html
index 712c4b3..70aba68 100644
--- a/docs/test_kit/tx.html
+++ b/docs/test_kit/tx.html
@@ -1262,9 +1262,9 @@ <h2 id="unset_treasury_donation"><pre class="hljs language-aiken">unset_treasury
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../js/index.js?v=1768998915"></script>
+    <script src="../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../search-data.js?v=1768998915"></script>
+    <script src="../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {
diff --git a/docs/test_kit/tx/mock.html b/docs/test_kit/tx/mock.html
index 52fbe8d..f3b6145 100644
--- a/docs/test_kit/tx/mock.html
+++ b/docs/test_kit/tx/mock.html
@@ -1542,9 +1542,9 @@ <h2 id="mock_transaction_hash"><pre class="hljs language-aiken">mock_transaction
     <script src="https://unpkg.com/@popperjs/core@2"></script>
     <script src="https://unpkg.com/tippy.js@6"></script>
     <script src="../../js/lunr.min.js?v=1.1.21"></script>
-    <script src="../../js/index.js?v=1768998915"></script>
+    <script src="../../js/index.js?v=1769000120"></script>
     <!-- Load the search index using JSONP to avoid CORS issues -->
-    <script src="../../search-data.js?v=1768998915"></script>
+    <script src="../../search-data.js?v=1769000120"></script>
     <script>
       void function() {
         if (typeof tippy !== "undefined") {