docs: update docs

Author: solidsnakedev

docs/content/docs/getting-started/data/basic-construction.mdx

@@ -5,7 +5,7 @@ description: "Learn how to create fundamental Data types using constructors."
 
 ```typescript
 import assert from "node:assert/strict"
-import { Data } from "@evolution-sdk/evolution"
+import { Bytes, Data } from "@evolution-sdk/evolution"
 
 // Create a simple constructor with no fields
 const unit = new Data.Constr({ index: 0n, fields: [] })
@@ -14,15 +14,15 @@ console.log("Unit constructor:", unit)
 // Create a constructor with primitive fields
 const person = new Data.Constr({
   index: 1n,
-  fields: ["416c696365", 30n] // 'Alice' as hex and age
+  fields: [Bytes.fromHexUnsafe("416c696365"), 30n] // 'Alice' as bytes and age
 })
 console.log("Person constructor:", person)
 
 // Create a constructor with mixed field types
 const record = new Data.Constr({
   index: 2n,
   fields: [
-    "deadbeef", // bytes as hex string (ByteArray)
+    Bytes.fromHexUnsafe("deadbeef"), // bytes as Uint8Array (ByteArray)
     42n, // big integer (Int)
     [1n, 2n, 3n], // array of big integers (List)
     new Data.Constr({ index: 0n, fields: [] }) // nested constructor
@@ -32,7 +32,7 @@ const record = new Data.Constr({
 // Verify the construction worked
 assert.equal(person.index, 1n)
 assert.equal(person.fields.length, 2)
-assert.equal(person.fields[0], "416c696365") // 'Alice' in hex
+assert.deepEqual(person.fields[0], Bytes.fromHexUnsafe("416c696365")) // 'Alice' in hex
 assert.equal(person.fields[1], 30n)
 
 ```

docs/content/docs/getting-started/data/bytes-validate.mdx

@@ -1,16 +1,16 @@
 ---
 title: "Validate bytes"
-description: "Quick check for hex-like bytes strings using Data.isBytes."
+description: "Quick check for Uint8Array bytes using Data.isBytes."
 ---
 
 ```typescript
 import assert from "node:assert/strict"
-import { Data } from "@evolution-sdk/evolution"
+import { Bytes, Data } from "@evolution-sdk/evolution"
 
-const hex = "deadbeef"
-assert.equal(Data.isBytes(hex), true)
+const bytes = Bytes.fromHexUnsafe("deadbeef")
+assert.equal(Data.isBytes(bytes), true)
 
-const invalid = "not-hex"
+const invalid = "not-bytes"
 assert.equal(Data.isBytes(invalid), false)
 
 ```

docs/content/docs/getting-started/data/cbor-encoding-options.mdx

@@ -5,13 +5,13 @@ description: "Compare different CBOR encoding strategies for the same data."
 
 ```typescript
 import assert from "node:assert/strict"
-import { CBOR, Data } from "@evolution-sdk/evolution"
+import { Bytes, CBOR, Data } from "@evolution-sdk/evolution"
 
 // Create complex data with unsorted elements (Maps should be standalone, not in constructor fields)
 const unsortedMap = new Map<Data.Data, Data.Data>([
-  ["7a65627261", 1n], // 'zebra' in hex
-  ["6170706c65", 2n], // 'apple' in hex
-  ["62616e616e61", 3n] // 'banana' in hex
+  [Bytes.fromHexUnsafe("7a65627261"), 1n], // 'zebra' in hex
+  [Bytes.fromHexUnsafe("6170706c65"), 2n], // 'apple' in hex
+  [Bytes.fromHexUnsafe("62616e616e61"), 3n] // 'banana' in hex
 ])
 
 // Create a constructor with only valid field types
@@ -20,7 +20,7 @@ const complexData = new Data.Constr({
   fields: [
     // List with mixed order
     [100n, 1n, 50n, 25n],
-    "deadbeef",
+    Bytes.fromHexUnsafe("deadbeef"),
     42n // additional data
   ]
 })

docs/content/docs/getting-started/data/complex-nested-structures.mdx

@@ -5,18 +5,18 @@ description: "Build sophisticated nested data structures with multiple levels an
 
 ```typescript
 import assert from "node:assert/strict"
-import { Data } from "@evolution-sdk/evolution"
+import { Bytes, Data } from "@evolution-sdk/evolution"
 
 // Create a complex user profile with nested data using only valid Data types
 const userProfile = new Data.Constr({
   index: 0n, // User constructor
   fields: [
-    "616c696365", // username 'alice' in hex
+    Bytes.fromHexUnsafe("616c696365"), // username 'alice' in hex
     new Data.Constr({
       index: 1n, // Profile constructor
       fields: [
         25n, // age
-        "deadbeef", // some profile data as hex
+        Bytes.fromHexUnsafe("deadbeef"), // some profile data as hex
         // Nested preferences constructor
         new Data.Constr({
           index: 2n, // Preferences constructor
@@ -35,18 +35,18 @@ const userProfile = new Data.Constr({
 const transaction = new Data.Constr({
   index: 10n, // Transaction constructor
   fields: [
-    "deadbeef1234", // transaction hash
+    Bytes.fromHexUnsafe("deadbeef1234"), // transaction hash
     1000000n, // amount in microADA
     new Data.Constr({
       index: 11n, // Address constructor
-      fields: ["616464723174657374"] // address data in hex
+      fields: [Bytes.fromHexUnsafe("616464723174657374")] // address data in hex
     }),
     // Simple metadata as nested constructor
     new Data.Constr({
       index: 12n, // Metadata constructor
       fields: [
         1640995200n, // timestamp
-        "7061796d656e74", // 'payment' as hex string
+        Bytes.fromHexUnsafe("7061796d656e74"), // 'payment' as hex string
         1n // status code
       ]
     })
@@ -55,7 +55,7 @@ const transaction = new Data.Constr({
 
 // Test deep structure access
 assert.equal(userProfile.index, 0n)
-assert.equal(userProfile.fields[0], "616c696365") // alice in hex
+assert.deepEqual(userProfile.fields[0], Bytes.fromHexUnsafe("616c696365")) // alice in hex
 
 // Verify nested constructor
 const profileData = userProfile.fields[1] as Data.Constr

docs/content/docs/getting-started/data/data.mdx

@@ -7,7 +7,7 @@ title: "Data"
 
 // #region data-nested-canonical
 import assert from "node:assert/strict"
-import { CBOR, Data } from "@evolution-sdk/evolution"
+import { Bytes, CBOR, Data } from "@evolution-sdk/evolution"
 // Create a complex nested data structure with:
 // - Constructor with index 1 containing multiple fields
 // - Nested constructors with different indices
@@ -28,9 +28,9 @@ const nestedUnsortedData = new Data.Constr({
     }),
     // Map with unsorted keys (will be sorted in canonical mode)
     new Map<Data.Data, Data.Data>([
-      ["deadbeef01", new Data.Constr({ index: 0n, fields: [] })],
-      ["beef", 19n],
-      ["deadbeef03", new Data.Constr({ index: 1n, fields: [] })]
+      [Bytes.fromHexUnsafe("deadbeef01"), new Data.Constr({ index: 0n, fields: [] })],
+      [Bytes.fromHexUnsafe("beef"), 19n],
+      [Bytes.fromHexUnsafe("deadbeef03"), new Data.Constr({ index: 1n, fields: [] })]
     ]),
     // Array of numbers
     [10n, 5n, 2n, 3n, 1n, 4n]

docs/content/docs/getting-started/data/error-handling-patterns.mdx

@@ -5,10 +5,10 @@ description: "Use Either patterns for safe data operations with proper error han
 
 ```typescript
 import assert from "node:assert/strict"
-import { Data, Either, pipe } from "@evolution-sdk/evolution"
+import { Bytes, Data, Either, pipe } from "@evolution-sdk/evolution"
 
 // Use built-in Either-based functions for safe operations
-const safeData = new Data.Constr({ index: 0n, fields: ["74657374", 42n] }) // 'test' as hex
+const safeData = new Data.Constr({ index: 0n, fields: [Bytes.fromHexUnsafe("74657374"), 42n] }) // 'test' as hex
 
 // Safe encoding using Data.Either namespace
 const encodingResult = Data.Either.toCBORHex(safeData)

docs/content/docs/getting-started/data/nested-canonical.mdx

@@ -5,7 +5,7 @@ description: "Complex nested Data encoding with canonical CBOR options."
 
 ```typescript
 import assert from "node:assert/strict"
-import { CBOR, Data } from "@evolution-sdk/evolution"
+import { Bytes, CBOR, Data } from "@evolution-sdk/evolution"
 
 const nestedUnsortedData = new Data.Constr({
   index: 1n,
@@ -15,9 +15,9 @@ const nestedUnsortedData = new Data.Constr({
       fields: [new Data.Constr({ index: 2n, fields: [] })]
     }),
     new Map<Data.Data, Data.Data>([
-      ["deadbeef01", new Data.Constr({ index: 0n, fields: [] })],
-      ["beef", 19n],
-      ["deadbeef03", new Data.Constr({ index: 1n, fields: [] })]
+      [Bytes.fromHexUnsafe("deadbeef01"), new Data.Constr({ index: 0n, fields: [] })],
+      [Bytes.fromHexUnsafe("beef"), 19n],
+      [Bytes.fromHexUnsafe("deadbeef03"), new Data.Constr({ index: 1n, fields: [] })]
     ]),
     [10n, 5n, 2n, 3n, 1n, 4n]
   ]

docs/content/docs/getting-started/data/roundtrip.mdx

@@ -5,9 +5,9 @@ description: "Encode a Data value to CBOR hex and decode back."
 
 ```typescript
 import assert from "node:assert/strict"
-import { CBOR, Data } from "@evolution-sdk/evolution"
+import { Bytes, CBOR, Data } from "@evolution-sdk/evolution"
 
-const original = new Data.Constr({ index: 0n, fields: ["beef", 19n] })
+const original = new Data.Constr({ index: 0n, fields: [Bytes.fromHexUnsafe("beef"), 19n] })
 const hexCbor = Data.toCBORHex(original, CBOR.CANONICAL_OPTIONS)
 const back = Data.fromCBORHex(hexCbor)
 assert.deepStrictEqual(back, original)

docs/content/docs/getting-started/data/working-with-maps.mdx

@@ -5,39 +5,50 @@ description: "Create and manipulate Data Maps with key-value pairs."
 
 ```typescript
 import assert from "node:assert/strict"
-import { Data } from "@evolution-sdk/evolution"
+import { Bytes, Data } from "@evolution-sdk/evolution"
 
-// Create a simple map with hex string keys and integer values
+// Create byte keys to use consistently
+const aliceKey = Bytes.fromHexUnsafe("616c696365") // 'alice' in hex
+const bobKey = Bytes.fromHexUnsafe("626f62") // 'bob' in hex
+const charlieKey = Bytes.fromHexUnsafe("636861726c6965") // 'charlie' in hex
+
+// Create a simple map with byte keys and integer values
 const userAges = new Map<Data.Data, Data.Data>([
-  ["616c696365", 25n], // 'alice' in hex
-  ["626f62", 30n], // 'bob' in hex
-  ["636861726c6965", 35n] // 'charlie' in hex
+  [aliceKey, 25n],
+  [bobKey, 30n],
+  [charlieKey, 35n]
 ])
 
 console.log("User ages map:", userAges)
 
-// Create a map with constructor keys and hex string values
+// Create constructor keys to use consistently
+const pendingKey = new Data.Constr({ index: 0n, fields: [] })
+const approvedKey = new Data.Constr({ index: 1n, fields: [] })
+const rejectedKey = new Data.Constr({ index: 2n, fields: [] })
+
+// Create a map with constructor keys and byte values
 const statusMap = new Map<Data.Data, Data.Data>([
-  [new Data.Constr({ index: 0n, fields: [] }), "70656e64696e67"], // 'pending' in hex
-  [new Data.Constr({ index: 1n, fields: [] }), "617070726f766564"], // 'approved' in hex
-  [new Data.Constr({ index: 2n, fields: [] }), "72656a6563746564"] // 'rejected' in hex
+  [pendingKey, Bytes.fromHexUnsafe("70656e64696e67")], // 'pending' in hex
+  [approvedKey, Bytes.fromHexUnsafe("617070726f766564")], // 'approved' in hex
+  [rejectedKey, Bytes.fromHexUnsafe("72656a6563746564")] // 'rejected' in hex
 ])
 
-// Demonstrate map usage - Maps are Data types themselves, not constructor fields
-console.log("Status for constructor 0:", statusMap.get(new Data.Constr({ index: 0n, fields: [] })))
+// Demonstrate map usage - use the same key reference for lookups
+console.log("Alice's age:", userAges.get(aliceKey))
+console.log("Status for pending:", statusMap.get(pendingKey))
 
-// Create a constructor that references the maps via indexes or simple structure
+// Create a constructor that contains Data values
 const dataRecord = new Data.Constr({
   index: 1n,
   fields: [
     25n, // alice's age directly
-    "deadbeef", // some data
+    Bytes.fromHexUnsafe("deadbeef"), // some data
     42n // more data
   ]
 })
 
-// Verify map operations
-assert.equal(userAges.get("616c696365"), 25n) // alice's age
+// Verify map operations - use same key references
+assert.deepEqual(userAges.get(aliceKey), 25n) // alice's age
 assert.equal(userAges.size, 3)
 assert.equal(dataRecord.fields.length, 3)