feat: upgrade modules

Author: solidsnakedev

packages/evolution/src/Certificate.ts

@@ -176,24 +176,14 @@ export const CDDLSchema = Schema.Union(
   Schema.Tuple(
     Schema.Literal(9n),
     Credential.CDDLSchema,
-    Schema.Union(
-      Schema.Tuple(Schema.Literal(0), Schema.Uint8ArrayFromSelf),
-      Schema.Tuple(Schema.Literal(1), Schema.Uint8ArrayFromSelf),
-      Schema.Tuple(Schema.Literal(2)),
-      Schema.Tuple(Schema.Literal(3))
-    )
+    DRep.CDDLSchema
   ),
   // 10: stake_vote_deleg_cert = (10, stake_credential, pool_keyhash, drep)
   Schema.Tuple(
     Schema.Literal(10n),
     Credential.CDDLSchema,
     CBOR.ByteArray,
-    Schema.Union(
-      Schema.Tuple(Schema.Literal(0), Schema.Uint8ArrayFromSelf),
-      Schema.Tuple(Schema.Literal(1), Schema.Uint8ArrayFromSelf),
-      Schema.Tuple(Schema.Literal(2)),
-      Schema.Tuple(Schema.Literal(3))
-    )
+    DRep.CDDLSchema,
   ),
   // 11: stake_reg_deleg_cert = (11, stake_credential, pool_keyhash, coin)
   Schema.Tuple(Schema.Literal(11n), Credential.CDDLSchema, CBOR.ByteArray, CBOR.Integer),

packages/evolution/src/DRep.ts

@@ -44,10 +44,10 @@ export const DRep = Schema.Union(
 export type DRep = typeof DRep.Type
 
 export const CDDLSchema = Schema.Union(
-  Schema.Tuple(Schema.Literal(0), Schema.Uint8ArrayFromSelf),
-  Schema.Tuple(Schema.Literal(1), Schema.Uint8ArrayFromSelf),
-  Schema.Tuple(Schema.Literal(2)),
-  Schema.Tuple(Schema.Literal(3))
+  Schema.Tuple(Schema.Literal(0n), Schema.Uint8ArrayFromSelf),
+  Schema.Tuple(Schema.Literal(1n), Schema.Uint8ArrayFromSelf),
+  Schema.Tuple(Schema.Literal(2n)),
+  Schema.Tuple(Schema.Literal(3n))
 )
 
 /**
@@ -64,41 +64,41 @@ export const FromCDDL = Schema.transformOrFail(CDDLSchema, Schema.typeSchema(DRe
       switch (toA._tag) {
         case "KeyHashDRep": {
           const keyHashBytes = yield* ParseResult.encode(KeyHash.FromBytes)(toA.keyHash)
-          return [0, keyHashBytes] as const
+          return [0n, keyHashBytes] as const
         }
         case "ScriptHashDRep": {
           const scriptHashBytes = yield* ParseResult.encode(ScriptHash.FromBytes)(toA.scriptHash)
-          return [1, scriptHashBytes] as const
+          return [1n, scriptHashBytes] as const
         }
         case "AlwaysAbstainDRep":
-          return [2] as const
+          return [2n] as const
         case "AlwaysNoConfidenceDRep":
-          return [3] as const
+          return [3n] as const
       }
     }),
   decode: (fromA) =>
     Eff.gen(function* () {
       const [tag, ...rest] = fromA
       switch (tag) {
-        case 0: {
+        case 0n: {
           const keyHash = yield* ParseResult.decode(KeyHash.FromBytes)(rest[0] as Uint8Array)
           return yield* ParseResult.decode(DRep)({
             _tag: "KeyHashDRep",
             keyHash
           })
         }
-        case 1: {
+        case 1n: {
           const scriptHash = yield* ParseResult.decode(ScriptHash.FromBytes)(rest[0] as Uint8Array)
           return yield* ParseResult.decode(DRep)({
             _tag: "ScriptHashDRep",
             scriptHash
           })
         }
-        case 2:
+        case 2n:
           return yield* ParseResult.decode(DRep)({
             _tag: "AlwaysAbstainDRep"
           })
-        case 3:
+        case 3n:
           return yield* ParseResult.decode(DRep)({
             _tag: "AlwaysNoConfidenceDRep"
           })

packages/evolution/src/GovernanceAction.ts

@@ -89,7 +89,7 @@ export class ParameterChangeAction extends Schema.TaggedClass<ParameterChangeAct
  * @category schemas
  */
 export const ParameterChangeActionCDDL = Schema.Tuple(
-  Schema.Literal(0), // action type
+  Schema.Literal(0n), // action type
   Schema.NullOr(GovActionIdCDDL), // gov_action_id / nil
   CBOR.RecordSchema, // protocol_param_update
   Schema.NullOr(CBOR.ByteArray) // policy_hash / nil
@@ -115,7 +115,7 @@ export const ParameterChangeActionFromCDDL = Schema.transformOrFail(
         const policyHash = action.policyHash ? yield* ParseResult.encode(ScriptHash.FromBytes)(action.policyHash) : null
 
         // Return as CBOR tuple
-        return [0, govActionId, protocolParamUpdate, policyHash] as const
+        return [0n, govActionId, protocolParamUpdate, policyHash] as const
       }),
     decode: (cddl) =>
       Eff.gen(function* () {
@@ -157,7 +157,7 @@ export class HardForkInitiationAction extends Schema.TaggedClass<HardForkInitiat
  * @category schemas
  */
 export const HardForkInitiationActionCDDL = Schema.Tuple(
-  Schema.Literal(1), // action type
+  Schema.Literal(1n), // action type
   Schema.NullOr(GovActionIdCDDL), // gov_action_id / nil
   Schema.Tuple(CBOR.Integer, CBOR.Integer), // protocol_version = [major, minor]
   Schema.NullOr(CBOR.ByteArray) // policy_hash / nil
@@ -183,7 +183,7 @@ export const HardForkInitiationActionFromCDDL = Schema.transformOrFail(
 
         // Return as CBOR tuple
         return [
-          1,
+          1n,
           govActionId,
           [BigInt(action.protocolVersion[0]), BigInt(action.protocolVersion[1])],
           policyHash
@@ -231,7 +231,7 @@ export class TreasuryWithdrawalsAction extends Schema.TaggedClass<TreasuryWithdr
  * @category schemas
  */
 export const TreasuryWithdrawalsActionCDDL = Schema.Tuple(
-  Schema.Literal(2), // action type
+  Schema.Literal(2n), // action type
   Schema.MapFromSelf({
     key: CBOR.ByteArray, // reward_account as bytes
     value: CBOR.Integer // coin as bigint
@@ -260,7 +260,7 @@ export const TreasuryWithdrawalsActionFromCDDL = Schema.transformOrFail(
         const policyHash = action.policyHash ? yield* ParseResult.encode(ScriptHash.FromBytes)(action.policyHash) : null
 
         // Return as CBOR tuple
-        return [2, withdrawals, policyHash] as const
+        return [2n, withdrawals, policyHash] as const
       }),
     decode: (cddl) =>
       Eff.gen(function* () {
@@ -300,7 +300,7 @@ export class NoConfidenceAction extends Schema.TaggedClass<NoConfidenceAction>()
  * @category schemas
  */
 export const NoConfidenceActionCDDL = Schema.Tuple(
-  Schema.Literal(3), // action type
+  Schema.Literal(3n), // action type
   Schema.NullOr(GovActionIdCDDL) // gov_action_id / nil
 )
 
@@ -322,7 +322,7 @@ export const NoConfidenceActionFromCDDL = Schema.transformOrFail(
           : null
 
         // Return as CBOR tuple
-        return [3, govActionId] as const
+        return [3n, govActionId] as const
       }),
     decode: (cddl) =>
       Eff.gen(function* () {
@@ -359,7 +359,7 @@ export class UpdateCommitteeAction extends Schema.TaggedClass<UpdateCommitteeAct
  * @category schemas
  */
 export const UpdateCommitteeActionCDDL = Schema.Tuple(
-  Schema.Literal(4), // action type
+  Schema.Literal(4n), // action type
   Schema.NullOr(GovActionIdCDDL), // gov_action_id / nil
   Schema.Array(CBOR.CBORSchema), // set<committee_cold_credential>
   CBOR.MapSchema, // { * committee_cold_credential => committee_hot_credential }
@@ -387,7 +387,7 @@ export const UpdateCommitteeActionFromCDDL = Schema.transformOrFail(
         const threshold = yield* ParseResult.encode(CBOR.CBORSchema)(action.threshold)
 
         // Return as CBOR tuple
-        return [4, govActionId, membersToRemove, membersToAdd, threshold] as const
+        return [4n, govActionId, membersToRemove, membersToAdd, threshold] as const
       }),
     decode: (cddl) =>
       Eff.gen(function* () {
@@ -425,7 +425,7 @@ export class NewConstitutionAction extends Schema.TaggedClass<NewConstitutionAct
  * @category schemas
  */
 export const NewConstitutionActionCDDL = Schema.Tuple(
-  Schema.Literal(5), // action type
+  Schema.Literal(5n), // action type
   Schema.NullOr(GovActionIdCDDL), // gov_action_id / nil
   CBOR.CBORSchema // constitution
 )
@@ -449,7 +449,7 @@ export const NewConstitutionActionFromCDDL = Schema.transformOrFail(
         const constitution = yield* ParseResult.encode(CBOR.CBORSchema)(action.constitution)
 
         // Return as CBOR tuple
-        return [5, govActionId, constitution] as const
+        return [5n, govActionId, constitution] as const
       }),
     decode: (cddl) =>
       Eff.gen(function* () {
@@ -483,7 +483,7 @@ export class InfoAction extends Schema.TaggedClass<InfoAction>()("InfoAction", {
  * @category schemas
  */
 export const InfoActionCDDL = Schema.Tuple(
-  Schema.Literal(6) // action type
+  Schema.Literal(6n) // action type
 )
 
 /**
@@ -497,7 +497,7 @@ export const InfoActionFromCDDL = Schema.transformOrFail(InfoActionCDDL, Schema.
   encode: (_action) =>
     Eff.gen(function* () {
       // Return as CBOR tuple
-      return [6] as const
+      return [6n] as const
     }),
   decode: (_cddl) =>
     Eff.gen(function* () {

packages/evolution/src/Mint.ts

@@ -219,10 +219,10 @@ export const policyCount = (mint: Mint): number => mint.size
 export const equals = (self: Mint, that: Mint): boolean => Equal.equals(self, that)
 
 export const CDDLSchema = Schema.MapFromSelf({
-  key: CBOR.ByteArray, // Policy ID as Uint8Array (28 bytes)
+  key: CBOR.ByteArray, // Policy ID as 28-byte Uint8Array
   value: Schema.MapFromSelf({
     key: CBOR.ByteArray, // Asset name as Uint8Array (variable length)
-    value: CBOR.Integer // Amount as number (will be converted to NonZeroInt64)
+    value: CBOR.Integer // Amount as nonZeroInt64
   })
 })
 
@@ -240,16 +240,16 @@ export const CDDLSchema = Schema.MapFromSelf({
  * @since 2.0.0
  * @category schemas
  */
-export const MintCDDLSchema = Schema.transformOrFail(CDDLSchema, Schema.typeSchema(Mint), {
+export const FromCDDL = Schema.transformOrFail(Schema.encodedSchema(CDDLSchema), Schema.typeSchema(Mint), {
   strict: true,
   encode: (toA) =>
     Eff.gen(function* () {
       // Convert Mint to raw Map data for CBOR encoding
-      const outerMap = new Map<Uint8Array, Map<Uint8Array, bigint>>()
+      const outerMap = new Map() as Map<Uint8Array, Map<Uint8Array, bigint>>
 
       for (const [policyId, assetMap] of toA.entries()) {
         const policyIdBytes = yield* ParseResult.encode(PolicyId.FromBytes)(policyId)
-        const innerMap = new Map<Uint8Array, bigint>()
+        const innerMap = new Map() as Map<Uint8Array, bigint>
 
         for (const [assetName, amount] of assetMap.entries()) {
           const assetNameBytes = yield* ParseResult.encode(AssetName.FromBytes)(assetName)
@@ -294,7 +294,7 @@ export const MintCDDLSchema = Schema.transformOrFail(CDDLSchema, Schema.typeSche
 export const FromCBORBytes = (options: CBOR.CodecOptions = CBOR.CML_DEFAULT_OPTIONS) =>
   Schema.compose(
     CBOR.FromBytes(options), // Uint8Array → CBOR
-    MintCDDLSchema // CBOR → Mint
+    FromCDDL // CBOR → Mint
   ).annotations({
     identifier: "Mint.FromCBORBytes",
     title: "Mint from CBOR Bytes",

packages/evolution/src/Pointer.ts

@@ -1,4 +1,4 @@
-import { Schema, FastCheck } from "effect"
+import { FastCheck,Schema } from "effect"
 
 import * as Natural from "./Natural.js"
 

packages/evolution/src/PrivateKey.ts

@@ -5,7 +5,9 @@ import { wordlist } from "@scure/bip39/wordlists/english"
 import { Data, Effect as Eff, FastCheck, ParseResult, Schema } from "effect"
 import sodium from "libsodium-wrappers-sumo"
 
-import { Bytes32, Bytes64, VKey } from "./index.js"
+import * as Bytes32 from "./Bytes32.js"
+import * as Bytes64 from "./Bytes64.js"
+import * as VKey from "./VKey.js"
 
 /**
  * Error class for PrivateKey related operations.