feat: update modules

Author: solidsnakedev

packages/evolution/src/BaseAddress.ts

@@ -23,7 +23,15 @@ export class BaseAddress extends Schema.TaggedClass<BaseAddress>("BaseAddress")(
   networkId: NetworkId.NetworkId,
   paymentCredential: Credential.Credential,
   stakeCredential: Credential.Credential
-}) {}
+}) {
+  toString(): string {
+    return `BaseAddress { networkId: ${this.networkId}, paymentCredential: ${this.paymentCredential}, stakeCredential: ${this.stakeCredential} }`
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return this.toString()
+  }
+}
 
 export const FromBytes = Schema.transformOrFail(Bytes57.BytesSchema, BaseAddress, {
   strict: true,

packages/evolution/src/Certificate.ts

@@ -9,7 +9,10 @@ import * as DRep from "./DRep.js"
 import * as EpochNo from "./EpochNo.js"
 import * as Function from "./Function.js"
 import * as PoolKeyHash from "./PoolKeyHash.js"
+import * as PoolMetadata from "./PoolMetadata.js"
 import * as PoolParams from "./PoolParams.js"
+import * as Relay from "./Relay.js"
+import * as UnitInterval from "./UnitInterval.js"
 
 /**
  * Error class for Certificate related operations.
@@ -215,7 +218,19 @@ export const CDDLSchema = Schema.Union(
   // 2: stake_delegation = (2, stake_credential, pool_keyhash)
   Schema.Tuple(Schema.Literal(2n), Credential.CDDLSchema, CBOR.ByteArray),
   // 3: pool_registration = (3, pool_params)
-  Schema.Tuple(Schema.Literal(3n), PoolParams.CDDLSchema),
+  Schema.Tuple(
+    Schema.Literal(3n),
+    // Flattened PoolParams.CDDLSchema
+    CBOR.ByteArray, // operator (pool_keyhash as bytes)
+    CBOR.ByteArray, // vrf_keyhash (as bytes)
+    CBOR.Integer, // pledge (coin)
+    CBOR.Integer, // cost (coin)
+    UnitInterval.CDDLSchema, // margin
+    CBOR.ByteArray, // reward_account (bytes)
+    Schema.Array(CBOR.ByteArray), // pool_owners (array of addr_keyhash bytes)
+    Schema.Array(Schema.encodedSchema(Relay.FromCDDL)), // relays
+    Schema.NullOr(Schema.encodedSchema(PoolMetadata.FromCDDL)) // pool_metadata
+  ),
   // 4: pool_retirement = (4, pool_keyhash, epoch_no)
   Schema.Tuple(Schema.Literal(4n), CBOR.ByteArray, CBOR.Integer),
   // 7: reg_cert = (7, stake_credential , coin)
@@ -273,7 +288,8 @@ export const FromCDDL = Schema.transformOrFail(CDDLSchema, Schema.typeSchema(Cer
         }
         case "PoolRegistration": {
           const poolParamsCDDL = yield* ParseResult.encodeEither(PoolParams.FromCDDL)(toA.poolParams)
-          return [3n, poolParamsCDDL] as const
+          // Spread encoded PoolParams fields directly into the certificate tuple (flattening)
+          return [3n, ...poolParamsCDDL] as const
         }
         case "PoolRetirement": {
           const poolKeyHashBytes = yield* ParseResult.encodeEither(PoolKeyHash.FromBytes)(toA.poolKeyHash)
@@ -370,9 +386,41 @@ export const FromCDDL = Schema.transformOrFail(CDDLSchema, Schema.typeSchema(Cer
           return new StakeDelegation({ stakeCredential, poolKeyHash }, { disableValidation: true })
         }
         case 3n: {
-          // pool_registration = (3, pool_params)
-          const [, poolParamsCDDL] = fromA
-          const poolParams = yield* ParseResult.decodeEither(PoolParams.FromCDDL)(poolParamsCDDL)
+          // pool_registration = (3, ...pool_params fields flattened)
+          const [
+            ,
+            operatorBytes,
+            vrfKeyhashBytes,
+            pledge,
+            cost,
+            marginEncoded,
+            rewardAccountBytes,
+            poolOwnersBytes,
+            relaysEncoded,
+            poolMetadataEncoded
+          ] = fromA as unknown as readonly [
+            3n,
+            Uint8Array,
+            Uint8Array,
+            bigint,
+            bigint,
+            unknown,
+            Uint8Array,
+            ReadonlyArray<Uint8Array>,
+            ReadonlyArray<unknown>,
+            unknown | null
+          ]
+          const poolParams = yield* ParseResult.decodeEither(PoolParams.FromCDDL)([
+            operatorBytes,
+            vrfKeyhashBytes,
+            pledge,
+            cost,
+            marginEncoded as any,
+            rewardAccountBytes,
+            poolOwnersBytes as any,
+            relaysEncoded as any,
+            poolMetadataEncoded as any
+          ] as any)
           return new PoolRegistration({ poolParams }, { disableValidation: true })
         }
         case 4n: {

packages/evolution/src/DatumOption.ts

@@ -26,7 +26,15 @@ export class DatumOptionError extends Data.TaggedError("DatumOptionError")<{
  */
 export class DatumHash extends Schema.TaggedClass<DatumHash>()("DatumHash", {
   hash: Bytes32.BytesSchema
-}) {}
+}) {
+  toString(): string {
+    return `DatumHash { hash: ${this.hash} }`
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return this.toString()
+  }
+}
 
 export const DatumHashFromBytes = Schema.transform(Bytes32.BytesSchema, DatumHash, {
   strict: true,
@@ -45,7 +53,15 @@ export const DatumHashFromBytes = Schema.transform(Bytes32.BytesSchema, DatumHas
  */
 export class InlineDatum extends Schema.TaggedClass<InlineDatum>()("InlineDatum", {
   data: PlutusData.DataSchema
-}) {}
+}) {
+  toString(): string {
+    return `InlineDatum { data: ${this.data} }`
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return this.toString()
+  }
+}
 
 /**
  * Schema for DatumOption representing optional datum information in transaction outputs.
@@ -136,19 +152,19 @@ export const arbitrary = FastCheck.oneof(datumHashArbitrary, inlineDatumArbitrar
 
 /**
  * CDDL schema for DatumOption.
- * datum_option = [0, Bytes32// 1, data]
+ * datum_option = [0, Bytes32] / [1, #6.24(bytes)]
  *
  * Where:
  * - [0, Bytes32] represents a datum hash (tag 0 with 32-byte hash)
- * - [1, data] represents inline data (tag 1 with CBOR-encoded plutus data)
+ * - [1, #6.24(bytes)] represents inline data (tag 1 with CBOR tag 24 containing plutus data as bytes)
  *
  * @since 2.0.0
  * @category schemas
  */
 export const DatumOptionCDDLSchema = Schema.transformOrFail(
   Schema.Union(
     Schema.Tuple(Schema.Literal(0n), CBOR.ByteArray), // [0, Bytes32]
-    Schema.Tuple(Schema.Literal(1n), CBOR.CBORSchema) // [1, data] - data as CBOR bytes
+    Schema.Tuple(Schema.Literal(1n), CBOR.tag(24, Schema.Uint8ArrayFromSelf)) // [1, tag(24, bytes)] - PlutusData as bytes in tag 24
   ),
   Schema.typeSchema(DatumOptionSchema),
   {
@@ -158,7 +174,7 @@ export const DatumOptionCDDLSchema = Schema.transformOrFail(
         const result =
           toA._tag === "DatumHash"
             ? ([0n, toA.hash] as const) // Encode as [0, Bytes32]
-            : ([1n, PlutusData.plutusDataToCBORValue(toA.data)] as const) // Encode as [1, data]
+            : ([1n, { _tag: "Tag" as const, tag: 24 as const, value: PlutusData.toCBORBytes(toA.data) }] as const) // Encode as [1, tag(24, bytes)]
         return yield* E.right(result)
       }),
     decode: ([tag, value], _, ast) =>
@@ -167,11 +183,21 @@ export const DatumOptionCDDLSchema = Schema.transformOrFail(
           // Decode as DatumHash
           return yield* E.right(new DatumHash({ hash: value }, { disableValidation: true }))
         } else if (tag === 1n) {
-          // Decode as InlineDatum
+          // Decode as InlineDatum - value is now a CBOR tag 24 wrapper containing bytes
+          const taggedValue = value as { _tag: "Tag"; tag: number; value: Uint8Array }
+          if (taggedValue._tag !== "Tag" || taggedValue.tag !== 24) {
+            return yield* E.left(
+              new ParseResult.Type(
+                ast,
+                [tag, value],
+                `Invalid InlineDatum format: expected tag 24, got ${taggedValue._tag} with tag ${taggedValue.tag}`
+              )
+            )
+          }
           return yield* E.right(
             new InlineDatum(
               {
-                data: PlutusData.cborValueToPlutusData(value)
+                data: PlutusData.fromCBORBytes(taggedValue.value)
               },
               { disableValidation: true }
             )

packages/evolution/src/EnterpriseAddress.ts

@@ -22,7 +22,15 @@ export class EnterpriseAddressError extends Data.TaggedError("EnterpriseAddressE
 export class EnterpriseAddress extends Schema.TaggedClass<EnterpriseAddress>("EnterpriseAddress")("EnterpriseAddress", {
   networkId: NetworkId.NetworkId,
   paymentCredential: Credential.Credential
-}) {}
+}) {
+  toString(): string {
+    return `EnterpriseAddress { networkId: ${this.networkId}, paymentCredential: ${this.paymentCredential} }`
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return this.toString()
+  }
+}
 
 export const FromBytes = Schema.transformOrFail(Bytes29.BytesSchema, EnterpriseAddress, {
   strict: true,

packages/evolution/src/GovernanceAction.ts

@@ -69,7 +69,7 @@ export const GovActionIdFromCDDL = Schema.transformOrFail(GovActionIdCDDL, GovAc
       const [transactionIdBytes, govActionIndexNumber] = fromA
       // Convert CBOR types to domain types
       const transactionId = yield* ParseResult.decode(TransactionHash.FromBytes)(transactionIdBytes)
-      const govActionIndex = yield* ParseResult.decode(TransactionIndex.TransactionIndex)(Number(govActionIndexNumber))
+      const govActionIndex = yield* ParseResult.decode(TransactionIndex.TransactionIndex)(govActionIndexNumber)
       return new GovActionId({ transactionId, govActionIndex })
     })
 })

packages/evolution/src/KeyHash.ts

@@ -38,7 +38,7 @@ export class KeyHash extends Schema.TaggedClass<KeyHash>()("KeyHash", {
   }
 
   toString(): string {
-    return toHex(this)
+    return `KeyHash({ hash: ${this.hash} })`
   }
 }
 

packages/evolution/src/Mint.ts

@@ -325,16 +325,38 @@ export const FromCBORHex = (options: CBOR.CodecOptions = CBOR.CML_DEFAULT_OPTION
  * @since 2.0.0
  * @category arbitrary
  */
-export const arbitrary = FastCheck.array(
-  FastCheck.tuple(
-    PolicyId.arbitrary,
-    FastCheck.array(FastCheck.tuple(AssetName.arbitrary, NonZeroInt64.arbitrary.map(NonZeroInt64.make)), {
-      minLength: 1,
-      maxLength: 5
-    })
-  ),
-  { minLength: 0, maxLength: 5 }
-).map((entries) => fromEntries(entries))
+export const arbitrary: FastCheck.Arbitrary<Mint> = FastCheck.oneof(
+  // Sometimes generate an empty mint map
+  FastCheck.constant(empty()),
+  // Non-empty unique policies with unique assets per policy
+  FastCheck.uniqueArray(PolicyId.arbitrary, {
+    minLength: 1,
+    maxLength: 5,
+    selector: (p) => Bytes.toHexUnsafe(p.hash)
+  }).chain((policies) => {
+    const assetsForPolicy = () =>
+      FastCheck.uniqueArray(AssetName.arbitrary, {
+        minLength: 1,
+        maxLength: 5,
+        selector: (a) => Bytes.toHexUnsafe(a.bytes)
+      }).chain((names) =>
+        FastCheck.array(NonZeroInt64.arbitrary.map(NonZeroInt64.make), {
+          minLength: names.length,
+          maxLength: names.length
+        }).map((amounts) => names.map((n, i) => [n, amounts[i]] as const))
+      )
+
+    return FastCheck.array(assetsForPolicy(), { minLength: policies.length, maxLength: policies.length }).map(
+      (assetsEntries) =>
+        fromEntries(
+          policies.map((policy, idx) => [
+            policy,
+            assetsEntries[idx] as Array<[AssetName.AssetName, NonZeroInt64.NonZeroInt64]>
+          ])
+        )
+    )
+  })
+)
 
 // ============================================================================
 // Root Functions

packages/evolution/src/MultiAsset.ts

@@ -230,15 +230,32 @@ export const is = (value: unknown): value is MultiAsset => Schema.is(MultiAsset)
  * @since 2.0.0
  * @category arbitrary
  */
-export const arbitrary = FastCheck.array(
-  FastCheck.tuple(
-    PolicyId.arbitrary,
-    FastCheck.array(FastCheck.tuple(AssetName.arbitrary, PositiveCoin.arbitrary), { minLength: 1, maxLength: 5 }).map(
-      (tokens) => new Map(tokens)
+export const arbitrary: FastCheck.Arbitrary<MultiAsset> = FastCheck.uniqueArray(PolicyId.arbitrary, {
+  minLength: 1,
+  maxLength: 5,
+  selector: (p) => Bytes.toHexUnsafe(p.hash)
+}).chain((policies) => {
+  // For each unique policy, generate a unique set of asset names with aligned positive amounts
+  const assetsForPolicy = () =>
+    FastCheck.uniqueArray(AssetName.arbitrary, {
+      minLength: 1,
+      maxLength: 5,
+      selector: (a) => Bytes.toHexUnsafe(a.bytes)
+    }).chain((names) =>
+      // Generate exactly names.length amounts to pair with the unique names
+      FastCheck.array(PositiveCoin.arbitrary, { minLength: names.length, maxLength: names.length }).map((amounts) => {
+        const entries = names.map((n, i) => [n, amounts[i]] as const)
+        return new Map(entries)
+      })
     )
-  ),
-  { minLength: 1, maxLength: 5 }
-).map((entries) => make(new Map(entries)))
+
+  return FastCheck.array(assetsForPolicy(), { minLength: policies.length, maxLength: policies.length }).map(
+    (assetMaps) => {
+      const entries = policies.map((policy, idx) => [policy, assetMaps[idx]] as const)
+      return make(new Map(entries))
+    }
+  )
+})
 
 /**
  * CDDL schema for MultiAsset.

packages/evolution/src/NativeScripts.ts

@@ -1,4 +1,4 @@
-import { Data, Either as E, ParseResult, Schema } from "effect"
+import { Data, Either as E, FastCheck, ParseResult, Schema } from "effect"
 import type { ParseIssue } from "effect/ParseResult"
 
 import * as Bytes from "./Bytes.js"
@@ -307,6 +307,60 @@ export const internalDecodeCDDL = (cborTuple: NativeCDDL): E.Either<Native, Pars
     }
   })
 
+/**
+ * FastCheck arbitrary for Native scripts.
+ * Generates valid native scripts with bounded depth and sizes.
+ *
+ * Depth limit prevents exponential blow-up. At depth 0, only base cases are generated.
+ */
+const nativeArbitrary = (depth: number): FastCheck.Arbitrary<Native> => {
+  const baseSig = FastCheck.record({
+    type: FastCheck.constant("sig" as const),
+    // 28-byte keyhash (56 hex chars)
+    keyHash: FastCheck.hexaString({ minLength: 56, maxLength: 56 })
+  })
+
+  const baseBefore = FastCheck.record({
+    type: FastCheck.constant("before" as const),
+    slot: FastCheck.integer({ min: 0, max: 10_000_000 })
+  })
+
+  const baseAfter = FastCheck.record({
+    type: FastCheck.constant("after" as const),
+    slot: FastCheck.integer({ min: 0, max: 10_000_000 })
+  })
+
+  if (depth <= 0) {
+    return FastCheck.oneof(baseSig, baseBefore, baseAfter)
+  }
+
+  const sub = nativeArbitrary(depth - 1)
+  const scriptsArray = FastCheck.array(sub, { minLength: 0, maxLength: 3 })
+
+  const all = scriptsArray.map((scripts) => ({ type: "all" as const, scripts }))
+  const any = scriptsArray.map((scripts) => ({ type: "any" as const, scripts }))
+
+  const atLeast = FastCheck.array(sub, { minLength: 0, maxLength: 4 }).chain((scripts) =>
+    FastCheck.integer({ min: 0, max: scripts.length }).map((required) => ({
+      type: "atLeast" as const,
+      required,
+      scripts
+    }))
+  )
+
+  // Weight base cases a bit higher for performance and balance
+  return FastCheck.oneof(
+    { arbitrary: baseSig, weight: 3 },
+    { arbitrary: baseBefore, weight: 2 },
+    { arbitrary: baseAfter, weight: 2 },
+    { arbitrary: all, weight: 1 },
+    { arbitrary: any, weight: 1 },
+    { arbitrary: atLeast, weight: 1 }
+  )
+}
+
+export const arbitrary: FastCheck.Arbitrary<Native> = nativeArbitrary(2)
+
 /**
  * CBOR bytes transformation schema for Native.
  * Transforms between CBOR bytes and Native using CBOR encoding.

packages/evolution/src/Natural.ts

@@ -18,7 +18,7 @@ export class NaturalError extends Data.TaggedError("NaturalError")<{
  * @since 2.0.0
  * @category schemas
  */
-export const Natural = Schema.Positive.pipe(Schema.brand("Natural")).annotations({
+export const Natural = Schema.Positive.annotations({
   identifier: "Natural",
   title: "Natural Number",
   description: "A positive integer greater than 0"