feat: upgrade sdk modules

Author: solidsnakedev

package.json

@@ -34,6 +34,7 @@
     "@changesets/cli": "^2.29.6",
     "@effect/docgen": "^0.5.2",
     "@effect/eslint-plugin": "^0.3.2",
+    "@effect/language-service": "^0.39.0",
     "@effect/vitest": "^0.25.1",
     "@eslint/compat": "^1.3.2",
     "@eslint/eslintrc": "^3.3.1",

packages/evolution/src/sdk/Datum.ts

@@ -0,0 +1,62 @@
+/**
+ * Datum types and utilities for handling Cardano transaction data.
+ *
+ * This module provides types and functions for working with datum values
+ * that can be attached to UTxOs in Cardano transactions.
+ */
+
+export type Datum =
+  | {
+      type: "datumHash"
+      hash: string
+    }
+  | {
+      type: "inlineDatum"
+      inline: string
+    }
+
+// Type guards
+export const isDatumHash = (datum?: Datum): datum is { type: "datumHash"; hash: string } =>
+  datum !== undefined && datum.type === "datumHash"
+
+export const isInlineDatum = (datum?: Datum): datum is { type: "inlineDatum"; inline: string } =>
+  datum !== undefined && datum.type === "inlineDatum"
+
+// Constructors
+export const makeDatumHash = (hash: string): Datum => ({
+  type: "datumHash",
+  hash
+})
+
+export const makeInlineDatum = (inline: string): Datum => ({
+  type: "inlineDatum",
+  inline
+})
+
+// Utility functions
+export const equals = (a: Datum, b: Datum): boolean => {
+  if (a.type !== b.type) return false
+  if (isDatumHash(a) && isDatumHash(b)) return a.hash === b.hash
+  if (isInlineDatum(a) && isInlineDatum(b)) return a.inline === b.inline
+  return false
+}
+
+// Array utilities
+export const filterHashes = (datums: Array<Datum>): Array<{ type: "datumHash"; hash: string }> =>
+  datums.filter(isDatumHash)
+
+export const filterInline = (datums: Array<Datum>): Array<{ type: "inlineDatum"; inline: string }> =>
+  datums.filter(isInlineDatum)
+
+export const unique = (datums: Array<Datum>): Array<Datum> =>
+  datums.filter((datum, index, self) => self.findIndex((d) => equals(datum, d)) === index)
+
+export const groupByType = (
+  datums: Array<Datum>
+): {
+  hashes: Array<{ type: "datumHash"; hash: string }>
+  inline: Array<{ type: "inlineDatum"; inline: string }>
+} => ({
+  hashes: filterHashes(datums),
+  inline: filterInline(datums)
+})

packages/evolution/src/sdk/Delegation.ts

@@ -0,0 +1,117 @@
+/**
+ * Delegation types and utilities for handling Cardano stake delegation.
+ *
+ * This module provides types and functions for working with stake delegation
+ * information, including pool assignments and reward balances.
+ */
+
+export interface Delegation {
+  readonly poolId: string | undefined
+  readonly rewards: bigint
+}
+
+// Constructors
+export const make = (poolId: string | undefined, rewards: bigint): Delegation => ({
+  poolId,
+  rewards
+})
+
+export const empty = (): Delegation => make(undefined, 0n)
+
+// Type guards
+export const isDelegated = (delegation: Delegation): boolean => delegation.poolId !== undefined
+
+export const hasRewards = (delegation: Delegation): boolean => delegation.rewards > 0n
+
+// Transformations
+export const addRewards = (delegation: Delegation, additionalRewards: bigint): Delegation => 
+  make(delegation.poolId, delegation.rewards + additionalRewards)
+
+export const subtractRewards = (delegation: Delegation, rewardsToSubtract: bigint): Delegation => {
+  const newRewards = delegation.rewards - rewardsToSubtract
+  return make(delegation.poolId, newRewards >= 0n ? newRewards : 0n)
+}
+
+// Comparisons
+export const equals = (a: Delegation, b: Delegation): boolean => 
+  a.poolId === b.poolId && a.rewards === b.rewards
+
+export const hasSamePool = (a: Delegation, b: Delegation): boolean => 
+  a.poolId === b.poolId
+
+export const compareByRewards = (a: Delegation, b: Delegation): number => {
+  const diff = a.rewards - b.rewards
+  return diff > 0n ? 1 : diff < 0n ? -1 : 0
+}
+
+export const compareByPoolId = (a: Delegation, b: Delegation): number => {
+  if (a.poolId === b.poolId) return 0
+  if (a.poolId === undefined) return -1
+  if (b.poolId === undefined) return 1
+  return a.poolId.localeCompare(b.poolId)
+}
+
+// Array utilities
+export const sortByRewards = (delegations: Array<Delegation>, ascending = true): Array<Delegation> =>
+  [...delegations].sort((a, b) => {
+    const comparison = compareByRewards(a, b)
+    return ascending ? comparison : -comparison
+  })
+
+export const sortByPoolId = (delegations: Array<Delegation>): Array<Delegation> =>
+  [...delegations].sort(compareByPoolId)
+
+export const filterDelegated = (delegations: Array<Delegation>): Array<Delegation> =>
+  delegations.filter(isDelegated)
+
+export const filterUndelegated = (delegations: Array<Delegation>): Array<Delegation> =>
+  delegations.filter(d => !isDelegated(d))
+
+export const filterWithRewards = (delegations: Array<Delegation>): Array<Delegation> =>
+  delegations.filter(hasRewards)
+
+export const filterByPool = (delegations: Array<Delegation>, poolId: string): Array<Delegation> =>
+  delegations.filter(d => d.poolId === poolId)
+
+export const getTotalRewards = (delegations: Array<Delegation>): bigint =>
+  delegations.reduce((total, delegation) => total + delegation.rewards, 0n)
+
+export const getUniquePoolIds = (delegations: Array<Delegation>): Array<string> =>
+  [...new Set(delegations.map(d => d.poolId).filter((id): id is string => id !== undefined))]
+
+export const groupByPool = (delegations: Array<Delegation>): Record<string, Array<Delegation>> =>
+  delegations.reduce((groups, delegation) => {
+    const poolId = delegation.poolId || "undelegated"
+    if (!groups[poolId]) groups[poolId] = []
+    groups[poolId].push(delegation)
+    return groups
+  }, {} as Record<string, Array<Delegation>>)
+
+// Statistical utilities
+export const getAverageRewards = (delegations: Array<Delegation>): bigint => {
+  if (delegations.length === 0) return 0n
+  return getTotalRewards(delegations) / BigInt(delegations.length)
+}
+
+export const getMaxRewards = (delegations: Array<Delegation>): bigint =>
+  delegations.reduce((max, delegation) => 
+    delegation.rewards > max ? delegation.rewards : max, 0n)
+
+export const getMinRewards = (delegations: Array<Delegation>): bigint =>
+  delegations.reduce((min, delegation) => 
+    delegation.rewards < min ? delegation.rewards : min, 
+    delegations[0]?.rewards || 0n)
+
+// Set operations
+export const unique = (delegations: Array<Delegation>): Array<Delegation> =>
+  delegations.filter((delegation, index, self) => 
+    self.findIndex(d => equals(delegation, d)) === index)
+
+export const find = (delegations: Array<Delegation>, predicate: (delegation: Delegation) => boolean): Delegation | undefined =>
+  delegations.find(predicate)
+
+export const findByPool = (delegations: Array<Delegation>, poolId: string): Delegation | undefined =>
+  find(delegations, d => d.poolId === poolId)
+
+export const contains = (delegations: Array<Delegation>, target: Delegation): boolean =>
+  delegations.some(delegation => equals(delegation, target))

packages/evolution/src/sdk/EvalRedeemer.ts

@@ -0,0 +1,7 @@
+// EvalRedeemer types and utilities for transaction evaluation
+
+export type EvalRedeemer = {
+  readonly ex_units: { readonly mem: number; readonly steps: number }
+  readonly redeemer_index: number
+  readonly redeemer_tag: "spend" | "mint" | "publish" | "withdraw" | "vote" | "propose"
+}

packages/evolution/src/sdk/OutRef.ts

@@ -0,0 +1,93 @@
+/**
+ * OutRef types and utilities for handling Cardano transaction output references.
+ *
+ * This module provides types and functions for working with transaction output references,
+ * which uniquely identify UTxOs by their transaction hash and output index.
+ */
+
+export interface OutRef {
+  txHash: string
+  outputIndex: number
+}
+
+// Constructors
+export const make = (txHash: string, outputIndex: number): OutRef => ({
+  txHash,
+  outputIndex
+})
+
+export const fromTxHashAndIndex = (txHash: string, outputIndex: number): OutRef => make(txHash, outputIndex)
+
+// Comparisons
+export const equals = (a: OutRef, b: OutRef): boolean => a.txHash === b.txHash && a.outputIndex === b.outputIndex
+
+export const compare = (a: OutRef, b: OutRef): number => {
+  const txHashComparison = a.txHash.localeCompare(b.txHash)
+  if (txHashComparison !== 0) return txHashComparison
+  return a.outputIndex - b.outputIndex
+}
+
+// String operations
+export const toString = (outRef: OutRef): string => `${outRef.txHash}#${outRef.outputIndex}`
+
+// Array utilities
+export const sort = (outRefs: Array<OutRef>): Array<OutRef> => [...outRefs].sort(compare)
+
+export const sortByTxHash = (outRefs: Array<OutRef>): Array<OutRef> =>
+  [...outRefs].sort((a, b) => a.txHash.localeCompare(b.txHash))
+
+export const sortByIndex = (outRefs: Array<OutRef>): Array<OutRef> =>
+  [...outRefs].sort((a, b) => a.outputIndex - b.outputIndex)
+
+export const unique = (outRefs: Array<OutRef>): Array<OutRef> =>
+  outRefs.filter((outRef, index, self) => self.findIndex((other) => equals(outRef, other)) === index)
+
+export const contains = (outRefs: Array<OutRef>, target: OutRef): boolean =>
+  outRefs.some((outRef) => equals(outRef, target))
+
+export const remove = (outRefs: Array<OutRef>, target: OutRef): Array<OutRef> =>
+  outRefs.filter((outRef) => !equals(outRef, target))
+
+export const find = (outRefs: Array<OutRef>, predicate: (outRef: OutRef) => boolean): OutRef | undefined =>
+  outRefs.find(predicate)
+
+export const filter = (outRefs: Array<OutRef>, predicate: (outRef: OutRef) => boolean): Array<OutRef> =>
+  outRefs.filter(predicate)
+
+// Group operations
+export const groupByTxHash = (outRefs: Array<OutRef>): Record<string, Array<OutRef>> =>
+  outRefs.reduce(
+    (groups, outRef) => {
+      const txHash = outRef.txHash
+      if (!groups[txHash]) groups[txHash] = []
+      groups[txHash].push(outRef)
+      return groups
+    },
+    {} as Record<string, Array<OutRef>>
+  )
+
+export const getTxHashes = (outRefs: Array<OutRef>): Array<string> => [
+  ...new Set(outRefs.map((outRef) => outRef.txHash))
+]
+
+export const getIndicesForTx = (outRefs: Array<OutRef>, txHash: string): Array<number> =>
+  outRefs.filter((outRef) => outRef.txHash === txHash).map((outRef) => outRef.outputIndex)
+
+// Set operations
+export const union = (setA: Array<OutRef>, setB: Array<OutRef>): Array<OutRef> => unique([...setA, ...setB])
+
+export const intersection = (setA: Array<OutRef>, setB: Array<OutRef>): Array<OutRef> =>
+  setA.filter((outRefA) => contains(setB, outRefA))
+
+export const difference = (setA: Array<OutRef>, setB: Array<OutRef>): Array<OutRef> =>
+  setA.filter((outRefA) => !contains(setB, outRefA))
+
+// Convenience functions
+export const isEmpty = (outRefs: Array<OutRef>): boolean => outRefs.length === 0
+
+export const size = (outRefs: Array<OutRef>): number => outRefs.length
+
+export const first = (outRefs: Array<OutRef>): OutRef | undefined => outRefs[0]
+
+export const last = (outRefs: Array<OutRef>): OutRef | undefined =>
+  outRefs.length > 0 ? outRefs[outRefs.length - 1] : undefined

packages/evolution/src/sdk/ProtocolParameters.ts

@@ -0,0 +1,81 @@
+/**
+ * Protocol Parameters types and utilities for Cardano network configuration.
+ *
+ * This module provides types and functions for working with Cardano protocol parameters,
+ * which define the operational rules and limits of the network.
+ */
+
+export type ProtocolParameters = {
+  readonly minFeeA: number
+  readonly minFeeB: number
+  readonly maxTxSize: number
+  readonly maxValSize: number
+  readonly keyDeposit: bigint
+  readonly poolDeposit: bigint
+  readonly drepDeposit: bigint
+  readonly govActionDeposit: bigint
+  readonly priceMem: number
+  readonly priceStep: number
+  readonly maxTxExMem: bigint
+  readonly maxTxExSteps: bigint
+  readonly coinsPerUtxoByte: bigint
+  readonly collateralPercentage: number
+  readonly maxCollateralInputs: number
+  readonly minFeeRefScriptCostPerByte: number
+  readonly costModels: {
+    readonly PlutusV1: Record<string, number>
+    readonly PlutusV2: Record<string, number>
+    readonly PlutusV3: Record<string, number>
+  }
+}
+
+/**
+ * Calculate the minimum fee for a transaction based on protocol parameters.
+ * 
+ * @param protocolParams - The current protocol parameters
+ * @param txSize - The transaction size in bytes
+ * @returns The minimum fee in lovelace
+ */
+export const calculateMinFee = (protocolParams: ProtocolParameters, txSize: number): bigint => {
+  return BigInt(protocolParams.minFeeA * txSize + protocolParams.minFeeB)
+}
+
+/**
+ * Calculate the UTxO cost based on the protocol parameters.
+ * 
+ * @param protocolParams - The current protocol parameters
+ * @param utxoSize - The UTxO size in bytes
+ * @returns The UTxO cost in lovelace
+ */
+export const calculateUtxoCost = (protocolParams: ProtocolParameters, utxoSize: number): bigint => {
+  return protocolParams.coinsPerUtxoByte * BigInt(utxoSize)
+}
+
+/**
+ * Get the cost model for a specific Plutus version.
+ * 
+ * @param protocolParams - The current protocol parameters
+ * @param version - The Plutus version
+ * @returns The cost model for the specified version
+ */
+export const getCostModel = (
+  protocolParams: ProtocolParameters,
+  version: "PlutusV1" | "PlutusV2" | "PlutusV3"
+): Record<string, number> => {
+  return protocolParams.costModels[version]
+}
+
+/**
+ * Check if the protocol parameters support a specific Plutus version.
+ * 
+ * @param protocolParams - The current protocol parameters
+ * @param version - The Plutus version to check
+ * @returns True if the version is supported
+ */
+export const supportsPlutusVersion = (
+  protocolParams: ProtocolParameters,
+  version: "PlutusV1" | "PlutusV2" | "PlutusV3"
+): boolean => {
+  const costModel = protocolParams.costModels[version]
+  return costModel && Object.keys(costModel).length > 0
+}