feat: upgra modules

Author: solidsnakedev

packages/evolution/src/sdk/Assets.ts

@@ -1,8 +1,84 @@
+import { Option } from "effect"
+
+import * as AssetName from "../core/AssetName.js"
+import * as Coin from "../core/Coin.js"
+import * as MultiAsset from "../core/MultiAsset.js"
+import * as CorePolicyId from "../core/PolicyId.js"
+import * as PositiveCoin from "../core/PositiveCoin.js"
+import * as CoreValue from "../core/Value.js"
+import * as Unit from "./Unit.js"
+
 export interface Assets {
   lovelace: bigint
   [key: string]: bigint
 }
 
+/**
+ * Sort assets according to CBOR canonical ordering rules (RFC 7049 section 3.9).
+ * Lovelace comes first, then assets sorted by policy ID length, then lexicographically.
+ */
+export const sortCanonical = (assets: Assets): Assets => {
+  const entries = Object.entries(assets).sort(([aUnit], [bUnit]) => {
+    const a = Unit.fromUnit(aUnit)
+    const b = Unit.fromUnit(bUnit)
+
+    // Compare policy lengths
+    // NOTE: all policies have the same length, because they must be 28 bytes
+    // but because Lovelace is in the assets we must compare the length
+    if (a.policyId.length !== b.policyId.length) {
+      return a.policyId.length - b.policyId.length
+    }
+
+    // If policy IDs are the same, compare asset names length
+    if (a.policyId === b.policyId) {
+      const aAssetName = a.assetName || ""
+      const bAssetName = b.assetName || ""
+      if (aAssetName.length !== bAssetName.length) {
+        return aAssetName.length - bAssetName.length
+      }
+      // If asset names have same length, compare them lexicographically
+      return aAssetName.localeCompare(bAssetName)
+    }
+
+    // If policy IDs have same length but are different, compare them lexicographically
+    return a.policyId.localeCompare(b.policyId)
+  })
+
+  return Object.fromEntries(entries) as Assets
+}
+
+/**
+ * Multiply all asset amounts by a factor.
+ * Useful for calculating fees, rewards, or scaling asset amounts.
+ */
+export const multiply = (assets: Assets, factor: bigint): Assets => {
+  const result: Record<string, bigint> = { lovelace: assets.lovelace * factor }
+
+  for (const [unit, amount] of Object.entries(assets)) {
+    if (unit !== "lovelace") {
+      result[unit] = amount * factor
+    }
+  }
+
+  return result as Assets
+}
+
+/**
+ * Negate all asset amounts.
+ * Useful for calculating what needs to be subtracted or for representing debts.
+ */
+export const negate = (assets: Assets): Assets => {
+  const result: Record<string, bigint> = { lovelace: -assets.lovelace }
+
+  for (const [unit, amount] of Object.entries(assets)) {
+    if (unit !== "lovelace") {
+      result[unit] = -amount
+    }
+  }
+
+  return result as Assets
+}
+
 // Constructor and factory functions
 export const make = (lovelace: bigint, tokens: Record<string, bigint> = {}): Assets => ({
   lovelace,
@@ -91,19 +167,6 @@ export const hasAsset = (assets: Assets, unit: string): boolean => {
   return unit in assets && assets[unit] > 0n
 }
 
-export const isValid = (assets: Assets): boolean => {
-  try {
-    // Check if it has required lovelace field and all values are bigint
-    if (typeof assets.lovelace !== "bigint") return false
-    for (const [unit, amount] of Object.entries(assets)) {
-      if (unit !== "lovelace" && typeof amount !== "bigint") return false
-    }
-    return true
-  } catch {
-    return false
-  }
-}
-
 export const isEmpty = (assets: Assets): boolean => {
   if (assets.lovelace > 0n) return false
   for (const [unit, amount] of Object.entries(assets)) {
@@ -120,16 +183,78 @@ export const getUnits = (assets: Assets): Array<string> => {
   return units
 }
 
-// String representation
-export const toString = (assets: Assets): string => {
-  const tokens = []
-  tokens.push(`lovelace: ${assets.lovelace.toString()}`)
+/**
+ * Convert a core Value to the Assets interface format.
+ */
+export const valueToAssets = (value: CoreValue.Value): Assets => {
+  const assets: Assets = { lovelace: 0n }
 
-  for (const [unit, amount] of Object.entries(assets)) {
-    if (unit !== "lovelace") {
-      tokens.push(`${unit}: ${amount.toString()}`)
+  // Add ADA (lovelace) from the Value
+  const adaAmount = CoreValue.getAda(value)
+  assets.lovelace = BigInt(adaAmount.toString())
+
+  // Get MultiAsset if it exists
+  const multiAsset = CoreValue.getAssets(value)
+  if (Option.isSome(multiAsset)) {
+    // Iterate through all policy IDs
+    const policyIds = MultiAsset.getPolicyIds(multiAsset.value)
+
+    for (const policyId of policyIds) {
+      const policyIdStr = CorePolicyId.toHex(policyId)
+      const assetsByPolicy = MultiAsset.getAssetsByPolicy(multiAsset.value, policyId)
+
+      for (const [assetName, amount] of assetsByPolicy) {
+        const assetNameStr = AssetName.toHex(assetName)
+        const unit = policyIdStr + assetNameStr
+        assets[unit] = BigInt(amount.toString())
+      }
+    }
+  }
+
+  return assets
+}
+
+/**
+ * Convert Assets interface format to a core Value.
+ */
+export const assetsToValue = (assets: Assets): CoreValue.Value => {
+  // Extract ADA amount (lovelace key)
+  const adaAmount = assets.lovelace || BigInt(0)
+  const coin = Coin.make(adaAmount)
+
+  // Filter out ADA to get only native assets
+  const nativeAssets = Object.entries(assets).filter(([unit]) => unit !== "lovelace")
+
+  if (nativeAssets.length === 0) {
+    // Only ADA, return OnlyCoin
+    return CoreValue.onlyCoin(coin)
+  }
+
+  // Build MultiAsset
+  const multiAssetMap = MultiAsset.empty()
+
+  for (const [unit, amount] of nativeAssets) {
+    const { assetName, policyId } = Unit.fromUnit(unit)
+    const positiveAmount = PositiveCoin.make(amount)
+
+    // Create core policy ID from hex string
+    const corePolicyId = CorePolicyId.fromHex(policyId)
+    // Create core asset name from hex string (or empty if undefined)
+    const coreAssetName = AssetName.fromHex(assetName || "")
+
+    // Get or create policy map
+    let policyMap = multiAssetMap.get(corePolicyId)
+    if (!policyMap) {
+      policyMap = new Map()
+      multiAssetMap.set(corePolicyId, policyMap)
     }
+
+    // Add asset to policy map
+    policyMap.set(coreAssetName, positiveAmount)
   }
 
-  return `{ ${tokens.join(", ")} }`
+  // Create the MultiAsset using the make function
+  const multiAsset = MultiAsset.make(multiAssetMap)
+
+  return CoreValue.withAssets(coin, multiAsset)
 }

packages/evolution/src/sdk/Label.ts

@@ -0,0 +1,58 @@
+import { fromHex } from "../core/Bytes.js"
+
+/**
+ * CRC8 implementation for label checksum calculation.
+ * Uses polynomial 0x07 (x^8 + x^2 + x + 1) as per CIP-67 specification.
+ */
+function crc8(data: Uint8Array): number {
+  let crc = 0
+  
+  for (let i = 0; i < data.length; i++) {
+    crc ^= data[i]
+    
+    for (let j = 0; j < 8; j++) {
+      if (crc & 0x80) {
+        crc = (crc << 1) ^ 0x07
+      } else {
+        crc = crc << 1
+      }
+    }
+  }
+  
+  return crc & 0xFF
+}
+
+/**
+ * Generate checksum for a hex-encoded number.
+ */
+function checksum(num: string): string {
+  return crc8(fromHex(num)).toString(16).padStart(2, "0")
+}
+
+/**
+ * Convert a number to a CIP-67 label format.
+ * Creates an 8-character hex string with format: 0[4-digit-hex][2-digit-checksum]0
+ */
+export function toLabel(num: number): string {
+  if (num < 0 || num > 65535) {
+    throw new Error(
+      `Label ${num} out of range: min label 1 - max label 65535.`
+    )
+  }
+  const numHex = num.toString(16).padStart(4, "0")
+  return "0" + numHex + checksum(numHex) + "0"
+}
+
+/**
+ * Parse a CIP-67 label format back to a number.
+ * Returns undefined if the label format is invalid or checksum doesn't match.
+ */
+export function fromLabel(label: string): number | undefined {
+  if (label.length !== 8 || !(label[0] === "0" && label[7] === "0")) {
+    return undefined
+  }
+  const numHex = label.slice(1, 5)
+  const num = parseInt(numHex, 16)
+  const check = label.slice(5, 7)
+  return check === checksum(numHex) ? num : undefined
+}

packages/evolution/src/sdk/PolicyId.ts

@@ -0,0 +1 @@
+export type PolicyId = string

packages/evolution/src/sdk/RewardAddress.ts

@@ -0,0 +1,57 @@
+import * as CoreAddressEras from "../core/AddressEras.js"
+import * as CoreRewardAccount from "../core/RewardAccount.js"
+import * as Credential from "./Credential.js"
+
+/**
+ * Reward address in bech32 format.
+ * Mainnet addresses start with "stake1"
+ * Testnet addresses start with "stake_test1"
+ */
+export type RewardAddress = string
+
+/**
+ * Convert bech32 reward address to core RewardAccount structure
+ */
+export const toCoreRewardAccount = (address: RewardAddress): CoreRewardAccount.RewardAccount => {
+  const addressEras = CoreAddressEras.fromBech32(address)
+  if (addressEras._tag !== "RewardAccount") {
+    throw new Error(`Invalid reward address: expected RewardAccount, got ${addressEras._tag}`)
+  }
+  return addressEras
+}
+
+/**
+ * Convert core RewardAccount structure to bech32 reward address
+ */
+export const fromCoreRewardAccount = (account: CoreRewardAccount.RewardAccount): RewardAddress =>
+  CoreAddressEras.toBech32(account)
+
+/**
+ * Create a reward address from a stake credential.
+ * A reward address is used for staking rewards and has only a stake credential.
+ * 
+ * @param stakeCredential - The stake credential (key hash or script hash)
+ * @param network - Target network (defaults to "Mainnet")
+ * @returns Bech32 reward address string
+ * 
+ * @example
+ * ```typescript
+ * const credential = { type: "Key", hash: "abcd1234..." }
+ * const rewardAddr = fromStakeCredential(credential, "Mainnet")
+ * // Returns: "stake1u9rlm65wjfkctdlyxl5cw87h9..."
+ * 
+ * const scriptCredential = { type: "Script", hash: "def5678..." }
+ * const testnetAddr = fromStakeCredential(scriptCredential, "Testnet")
+ * // Returns: "stake_test1ur9rlm65wjfkctdlyxl5cw87h9..."
+ * ```
+ */
+export const fromStakeCredential = (
+  stakeCredential: Credential.Credential,
+  network: Credential.Network = "Mainnet"
+): RewardAddress => {
+  const coreRewardAccount = new CoreRewardAccount.RewardAccount({
+    networkId: network === "Mainnet" ? 1 : 0,
+    stakeCredential: Credential.toCoreCredential(stakeCredential)
+  })
+  return CoreAddressEras.toBech32(coreRewardAccount)
+}

packages/evolution/src/sdk/Script.ts

@@ -1,5 +1,7 @@
 import { pipe } from "effect"
 
+import { fromHex } from "../core/Bytes.js"
+import * as CBOR from "../core/CBOR.js"
 import * as CoreScript from "../core/Script.js"
 import * as CoreScriptHash from "../core/ScriptHash.js"
 import type * as Credential from "./Credential.js"
@@ -110,3 +112,18 @@ export const scriptEquals = (a: Script, b: Script): boolean => a.type === b.type
  * The policy ID is identical to the script hash.
  */
 export const mintingPolicyToId = (script: Script): Credential.ScriptHash => toScriptHash(script)
+
+
+export const applyDoubleCborEncoding = (script: string): string => {
+  // Convert hex string to bytes, then encode as CBOR bytes, then back to hex
+  const bytes = fromHex(script)
+  const doubleCborBytes = CBOR.toCBORBytes(bytes)
+  return CBOR.toCBORHex(doubleCborBytes)
+}
+
+export const applySingleCborEncoding = (script: string): string => {
+  // Convert hex string to bytes, then encode as CBOR bytes, then back to hex
+  const bytes = fromHex(script)
+  const singleCborBytes = CBOR.toCBORBytes(bytes)
+  return CBOR.toCBORHex(singleCborBytes)
+}

packages/evolution/src/sdk/UTxO.ts

@@ -1,13 +1,18 @@
 import * as Assets from "./Assets.js"
+import type * as Script from "./Script.js"
 
 export type Datum =
   | {
+      type: "datumHash"
       hash: string
     }
   | {
+      type: "inlineDatum"
       inline: string
     }
-  | undefined
+  | {
+      type: "noDatum"
+    }
 
 export interface OutRef {
   txHash: string
@@ -19,8 +24,8 @@ export interface UTxO {
   outputIndex: number
   address: string
   assets: Assets.Assets
-  datumOption?: Datum
-  scriptRef?: string
+  datumOption: Datum
+  scriptRef?: Script.Script
 }
 
 export const hasAssets = (utxo: UTxO): boolean => !Assets.isEmpty(utxo.assets)
@@ -54,9 +59,9 @@ export const makeOutRef = (txHash: string, outputIndex: number): OutRef => ({
 })
 
 // Datum type guards and utilities
-export const isDatumHash = (datum: Datum): datum is { hash: string } => datum !== undefined && "hash" in datum
+export const isDatumHash = (datum: Datum): datum is { type: "datumHash"; hash: string } => datum !== undefined && "hash" in datum
 
-export const isInlineDatum = (datum: Datum): datum is { inline: string } => datum !== undefined && "inline" in datum
+export const isInlineDatum = (datum: Datum): datum is { type: "inlineDatum"; inline: string } => datum !== undefined && "inline" in datum
 
 export const getDatumHash = (utxo: UTxO): string | undefined =>
   isDatumHash(utxo.datumOption) ? utxo.datumOption.hash : undefined
@@ -85,11 +90,13 @@ export const withDatum = (utxo: UTxO, datumOption: Datum): UTxO => ({
 
 export const withoutDatum = (utxo: UTxO): UTxO => ({
   ...utxo,
-  datumOption: undefined
+  datumOption: {
+    type: "noDatum"
+  }
 })
 
 // Script operations
-export const withScript = (utxo: UTxO, scriptRef: string): UTxO => ({
+export const withScript = (utxo: UTxO, scriptRef: Script.Script): UTxO => ({
   ...utxo,
   scriptRef
 })