diff --git a/cabal.project b/cabal.project
index 616c4d1a..faf8e5e3 100644
--- a/cabal.project
+++ b/cabal.project
@@ -15,21 +15,8 @@ repository cardano-haskell-packages
     d4a35cd3121aa00d18544bb0ac01c3e1691d618f462c46129271bccf39f7e8ee
 
 index-state:
-  , hackage.haskell.org 2025-04-15T08:13:08Z
-  , cardano-haskell-packages 2025-04-11T16:42:25Z
-
-constraints:
-  plutus-core == 1.40.0.0,
-  plutus-ledger-api == 1.40.0.0
-
-allow-newer:
-  *:plutus-core,
-  *:plutus-ledger-api,
-
-allow-older:
-  -- NOTE: Currently, plutarch depends on plutus-core version 1.40, while the rest of the (cardano) world is at 1.37.
-  -- TODO: Delete when plutarch is moving to 1.37
-  plutarch:plutus-core
+  , hackage.haskell.org 2025-08-14T14:31:31Z
+  , cardano-haskell-packages 2025-08-14T14:31:31Z
 
 with-compiler: ghc-9.6.6
 
@@ -40,11 +27,29 @@ packages:
     src/examples/regulated-stablecoin
     src/examples/aiken/haskell
 
+constraints:
+  cardano-api == 10.17.2.0
+  , plutus-core == 1.51.0.0
+  , plutus-ledger-api == 1.51.0.0
+  , quickcheck-dynamic == 3.4.2
+
+allow-older:
+  *:cardano-api
+  , *:plutus-core
+  , *:plutus-ledger-api
+  , *:QuickCheck
+
+allow-newer:
+  *:cardano-api
+  , *:plutus-core
+  , *:plutus-ledger-api
+  , *:QuickCheck
+
 source-repository-package
   type: git
   location: https://github.com/j-mueller/sc-tools
-  tag: 100452e6b64200cdffcb2582be07c47e1efebb6b
-  --sha256: sha256-65swdL2zk1mbqdjten6SIX/2v8tADOX4AhzyE0ocpwY=
+  tag: 1240643dbb8af5df075f4b1894a672744e733a7f
+  --sha256: sha256-Jqj4DHEsXBrTSZSWqFiGKCNXwavOd2kAAFb8cPNZdgs=
   subdir:
     src/devnet
     src/coin-selection
@@ -58,9 +63,9 @@ source-repository-package
 
 source-repository-package
     type: git
-    location: https://github.com/Plutonomicon/plutarch-plutus
-    tag: f84a46287b06f36abf8d2d63bec7ff75d32f3e91
-    --sha256: sha256-gKBk9D6DHSEudq7P9+07yXWcgM/QX7NFp0tJXBodopM=
+    location: https://github.com/choener/plutarch-plutus
+    tag: 99315dada86e042bbc1dee5c5ccae158119031eb
+    --sha256: sha256-kgjYtDcqqEsF61QqK5eoxwL4Gbj9A0tAAqw6xH01NB0=
     subdir:
       .
       plutarch-ledger-api
@@ -70,8 +75,8 @@ source-repository-package
 source-repository-package
     type: git
     location: https://github.com/input-output-hk/catalyst-onchain-libs
-    tag: 2d8389099584e2d9735e9374895386c72d90517a
-    --sha256: sha256-sdeDXUiL1MbEtJYbN4URwpQ8CbUKjxxGXUxjj1qqi3E=
+    tag: 6c7156c441c18b2c76066eae1cce1578190c9cfd
+    --sha256: sha256-bGf20nAEeMJ3iajMqRBN88BQSMVTXecXl6CztHiZUtA=
     subdir:
       src/plutarch-onchain-lib
 
diff --git a/flake.lock b/flake.lock
index 587574af..869b50fc 100644
--- a/flake.lock
+++ b/flake.lock
@@ -3,11 +3,11 @@
     "CHaP": {
       "flake": false,
       "locked": {
-        "lastModified": 1747320569,
-        "narHash": "sha256-h1ybAWeL8/ZsujXsM4UPrSOAzmkxZQ3AK/xWV6ZjmxI=",
+        "lastModified": 1763493280,
+        "narHash": "sha256-YeNs/lYuuel8c6W52pRrjx3h6tHO8899imCA7pghLTM=",
         "owner": "IntersectMBO",
         "repo": "cardano-haskell-packages",
-        "rev": "b5a1031cec2d9ca0f64980b451d8139682c46861",
+        "rev": "8a623ee338469a5631052b88fc7af7b540895a43",
         "type": "github"
       },
       "original": {
@@ -569,11 +569,11 @@
     "hackage_2": {
       "flake": false,
       "locked": {
-        "lastModified": 1747268671,
-        "narHash": "sha256-Pe0ZQAMlXFN0COv7D1tzL7aJ4H254bOMkuPawnQ9m00=",
+        "lastModified": 1763619216,
+        "narHash": "sha256-aMEdcgibwmE4fihEwODMZgZ6RwiZwbjF0V//rcZjQOQ=",
         "owner": "input-output-hk",
         "repo": "hackage.nix",
-        "rev": "7a5de1cd1b5e2cb23905e4890957230f97301d86",
+        "rev": "89a16af3bc7e01b8f836b18df1f3729ba35934a3",
         "type": "github"
       },
       "original": {
diff --git a/flake.nix b/flake.nix
index c8193199..3b629aaf 100644
--- a/flake.nix
+++ b/flake.nix
@@ -49,7 +49,7 @@
     inherit inputs;
     repoRoot = ./.;
     outputs = import ./nix/outputs.nix;
-    systems = [ "x86_64-linux" ]; # "x86_64-darwin" ];
+    systems = [ "x86_64-linux" ]; # "aarch64-darwin" ];
   };
 
   nixConfig = {
diff --git a/src/examples/aiken/haskell/aiken-example.cabal b/src/examples/aiken/haskell/aiken-example.cabal
index 2a2bc4c2..aba7f0c0 100644
--- a/src/examples/aiken/haskell/aiken-example.cabal
+++ b/src/examples/aiken/haskell/aiken-example.cabal
@@ -55,8 +55,6 @@ common lang
 library
   import:          lang
   exposed-modules:
-    Wst.Aiken.Blueprint
-    Wst.Aiken.BlueprintKey
     Wst.Aiken.Error
     Wst.Aiken.Offchain
     Wst.Cli
@@ -69,21 +67,17 @@ library
     , base
     , base16-bytestring
     , Blammo
-    , blockfrost-api
     , blockfrost-client-core
     , bytestring
     , cardano-api
-    , containers
     , convex-base
     , convex-blockfrost
     , convex-coin-selection
     , convex-optics
     , convex-wallet
-    , hset
     , lens
     , mtl
     , optparse-applicative
-    , plutus-core
     , plutus-ledger-api
     , programmable-tokens-offchain
     , programmable-tokens-onchain
@@ -99,7 +93,6 @@ test-suite aiken-example-test
     , aiken-example
     , base                          >=4.14.0
     , cardano-api
-    , containers
     , convex-base
     , convex-coin-selection
     , convex-wallet
diff --git a/src/examples/aiken/haskell/lib/Wst/Aiken/Blueprint.hs b/src/examples/aiken/haskell/lib/Wst/Aiken/Blueprint.hs
deleted file mode 100644
index 26fc33bf..00000000
--- a/src/examples/aiken/haskell/lib/Wst/Aiken/Blueprint.hs
+++ /dev/null
@@ -1,165 +0,0 @@
-{-# LANGUAGE NamedFieldPuns    #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE TupleSections     #-}
-
--- TODO: This can probably move to sc-tools
-
--- | Reading plutus scripts from blueprint JSON files
-module Wst.Aiken.Blueprint
-  ( BlueprintScriptVersion (..),
-    Blueprint (..),
-    BlueprintValidator (..),
-    Preamble (..),
-    loadFromFile,
-    loadFromFile_,
-    deserialise,
-    getPlutusV3,
-
-    -- * Etc.
-    unsafeDeserialiseScript,
-    fromCardanoApiScriptToProgram,
-    fromProgramToCardanoApiScript
-  )
-where
-
-import Cardano.Api (AnyPlutusScriptVersion, ScriptInAnyLang)
-import Cardano.Api.Shelley qualified as C
-import Control.Monad.Error.Lens (throwing)
-import Control.Monad.Except (MonadError)
-import Control.Monad.IO.Class (MonadIO (..))
-import Data.Aeson (FromJSON (..), ToJSON (..), withObject, (.:))
-import Data.Aeson qualified as Aeson
-import Data.ByteString qualified as BS
-import Data.ByteString.Base16 qualified as Base16
-import Data.ByteString.Lazy qualified as BSL
-import Data.ByteString.Short qualified as BSS
-import Data.Map (Map)
-import Data.Map qualified as Map
-import Data.Text (Text)
-import Data.Text qualified as T
-import Data.Text.Encoding qualified as TE
-import GHC.Generics (Generic)
-import PlutusCore qualified as PLC
-import PlutusLedgerApi.Common (MajorProtocolVersion (..),
-                               PlutusLedgerLanguage (..), ScriptForEvaluation,
-                               ScriptNamedDeBruijn (ScriptNamedDeBruijn),
-                               SerialisedScript, deserialisedScript,
-                               serialiseUPLC)
-import PlutusLedgerApi.Common qualified as PlutusLedgerApi
-import PlutusPrelude (over)
-import UntypedPlutusCore qualified as UPLC
-import Wst.Aiken.BlueprintKey (BlueprintKey)
-import Wst.Aiken.Error (AsBlueprintError (..))
-
--- | Plutus script version with a blueprint-specific JSON encoding
-newtype BlueprintScriptVersion = BlueprintScriptVersion AnyPlutusScriptVersion
-  deriving stock (Eq, Show)
-
-instance ToJSON BlueprintScriptVersion where
-  toJSON (BlueprintScriptVersion (C.AnyPlutusScriptVersion k)) = case k of
-    C.PlutusScriptV1 -> toJSON @String "v1"
-    C.PlutusScriptV2 -> toJSON @String "v2"
-    C.PlutusScriptV3 -> toJSON @String "v3"
-
-instance FromJSON BlueprintScriptVersion where
-  parseJSON = fmap (fmap BlueprintScriptVersion) $ Aeson.withText "BlueprintScriptVersion" $ \x -> case T.unpack x of
-    "v1" -> pure (C.AnyPlutusScriptVersion C.PlutusScriptV1)
-    "v2" -> pure (C.AnyPlutusScriptVersion C.PlutusScriptV2)
-    "v3" -> pure (C.AnyPlutusScriptVersion C.PlutusScriptV3)
-    v -> fail $ "Unexpected plutus script version: " <> v
-
-data Blueprint = Blueprint
-  { preamble :: Preamble,
-    validators :: Map BlueprintKey ScriptInAnyLang
-  }
-  deriving stock (Eq, Show, Generic)
-
-instance FromJSON Blueprint where
-  parseJSON = withObject "Blueprint" $ \obj ->
-    let mkb p v = Blueprint p <$> deserialise p v
-     in ( mkb
-            <$> obj .: "preamble"
-            <*> obj .: "validators"
-        )
-          >>= either fail pure
-
-data BlueprintValidator = BlueprintValidator
-  { title :: BlueprintKey,
-    compiledCode :: Text,
-    hash :: Text
-  }
-  deriving stock (Eq, Show, Generic)
-  deriving anyclass (ToJSON, FromJSON)
-
-data Preamble = Preamble
-  { description :: Text,
-    plutusVersion :: BlueprintScriptVersion
-  }
-  deriving stock (Eq, Show, Generic)
-
-instance FromJSON Preamble where
-  parseJSON = withObject "Preamble" $ \obj ->
-    Preamble
-      <$> obj .: "description"
-      <*> obj .: "plutusVersion"
-
-loadFromFile :: FilePath -> IO (Either String Blueprint)
-loadFromFile fp = Aeson.eitherDecode . BSL.fromStrict <$> BS.readFile fp
-
-loadFromFile_ :: (MonadIO m, MonadError err m, AsBlueprintError err) => FilePath -> m Blueprint
-loadFromFile_ fp =
-  liftIO (loadFromFile fp) >>= either (throwing _BlueprintJsonError) pure
-
-deserialise :: Preamble -> [BlueprintValidator] -> Either String (Map BlueprintKey ScriptInAnyLang)
-deserialise Preamble {plutusVersion = BlueprintScriptVersion v} validators =
-  Map.fromList <$> traverse (deserialiseScript v) validators
-
-deserialiseScript :: AnyPlutusScriptVersion -> BlueprintValidator -> Either String (BlueprintKey, ScriptInAnyLang)
-deserialiseScript (C.AnyPlutusScriptVersion v) BlueprintValidator {title, compiledCode} =
-  let lng = C.PlutusScriptLanguage v
-   in fmap ((title,) . C.ScriptInAnyLang lng) (deserialisePlutus v compiledCode)
-
-deserialisePlutus :: forall lang. (C.IsPlutusScriptLanguage lang) => C.PlutusScriptVersion lang -> Text -> Either String (C.Script lang)
-deserialisePlutus scriptVersion text = --first show $ C.deserialiseFromCBOR (C.proxyToAsType $ Proxy @(C.Script lang))
-  let bs = Base16.decodeLenient $ TE.encodeUtf8 text
-      -- lang = case scriptVersion of
-      --   C.PlutusScriptV1 -> PlutusV1
-      --   C.PlutusScriptV2 -> PlutusV2
-      --   C.PlutusScriptV3 -> PlutusV3
-  -- in fmap _ (unsafeDeserialiseScript lang (BSS.toShort bs))
-  in Right $ C.PlutusScript scriptVersion (C.PlutusScriptSerialised $ BSS.toShort bs)
-
--- | Extract the Plutus V3 script, fail if the script is not V3
-getPlutusV3 :: (MonadError err m, AsBlueprintError err) => ScriptInAnyLang -> m (C.Script C.PlutusScriptV3)
-getPlutusV3 (C.ScriptInAnyLang (C.PlutusScriptLanguage C.PlutusScriptV3) script) = pure script
-getPlutusV3 (C.ScriptInAnyLang otherLang _) =
-  throwing _UnexpectedPlutusVersionError (C.AnyPlutusScriptVersion C.PlutusScriptV3, C.AnyScriptLanguage otherLang)
-
-unsafeDeserialiseScript ::
-  PlutusLedgerLanguage
-  -- ^ the Plutus ledger language of the script.
-  -> SerialisedScript
-  -- ^ the script to deserialise.
-  -> Either String ScriptForEvaluation
-unsafeDeserialiseScript ll sScript = do
-  let majorProtocolVersion = if ll == PlutusV3 then MajorProtocolVersion 10 else MajorProtocolVersion 9
-  case PlutusLedgerApi.deserialiseScript ll majorProtocolVersion sScript of
-    Left err -> Left (show err)
-    Right s -> Right s
-
-type Script = UPLC.Program UPLC.DeBruijn PLC.DefaultUni PLC.DefaultFun ()
-
-fromCardanoApiScriptToProgram :: C.PlutusScript C.PlutusScriptV3 -> Either String Script
-fromCardanoApiScriptToProgram (C.PlutusScriptSerialised script) =
-  case unsafeDeserialiseScript PlutusV3 script of
-    Right (deserialisedScript -> ScriptNamedDeBruijn program) -> Right (toNameless program)
-    Left err -> Left err
-
-fromProgramToCardanoApiScript :: Script -> C.PlutusScript C.PlutusScriptV3
-fromProgramToCardanoApiScript script =
-  C.PlutusScriptSerialised $ serialiseUPLC script
-
-toNameless
-  :: UPLC.Program UPLC.NamedDeBruijn PLC.DefaultUni PLC.DefaultFun ()
-  -> UPLC.Program UPLC.DeBruijn PLC.DefaultUni PLC.DefaultFun ()
-toNameless = over UPLC.progTerm $ UPLC.termMapNames UPLC.unNameDeBruijn
diff --git a/src/examples/aiken/haskell/lib/Wst/Aiken/BlueprintKey.hs b/src/examples/aiken/haskell/lib/Wst/Aiken/BlueprintKey.hs
deleted file mode 100644
index 7626c5db..00000000
--- a/src/examples/aiken/haskell/lib/Wst/Aiken/BlueprintKey.hs
+++ /dev/null
@@ -1,10 +0,0 @@
-module Wst.Aiken.BlueprintKey(
-  BlueprintKey(..)
-) where
-
-import Data.Aeson (FromJSON (..), ToJSON (..))
-import Data.String (IsString (..))
-import Data.Text (Text)
-
-newtype BlueprintKey = BlueprintKey {unBlueprintKey :: Text}
-  deriving newtype (Eq, Ord, Show, ToJSON, FromJSON, IsString)
diff --git a/src/examples/aiken/haskell/lib/Wst/Aiken/Error.hs b/src/examples/aiken/haskell/lib/Wst/Aiken/Error.hs
index 2b3d515f..5ac4a7ab 100644
--- a/src/examples/aiken/haskell/lib/Wst/Aiken/Error.hs
+++ b/src/examples/aiken/haskell/lib/Wst/Aiken/Error.hs
@@ -11,33 +11,13 @@ module Wst.Aiken.Error(
 ) where
 
 import Blockfrost.Client.Core (BlockfrostError)
-import Cardano.Api (AnyPlutusScriptVersion, AnyScriptLanguage)
 import Control.Lens (makeClassyPrisms)
+import Convex.Aiken.Error (AsBlueprintError (..), AsLookupScriptFailure (..),
+                           BlueprintError (..), LookupScriptFailure (..))
 import Convex.CoinSelection (AsBalancingError (..), AsCoinSelectionError (..),
                              BalancingError, CoinSelectionError)
 import ProgrammableTokens.OffChain.Error (AsProgrammableTokensError (..),
                                           ProgrammableTokensError)
-import Wst.Aiken.BlueprintKey (BlueprintKey)
-
-data BlueprintError =
-
-  -- | Failed to convert 'ScriptInAnyLang' to the target script version
-  UnexpectedPlutusVersionError
-    { expectedVersion :: AnyPlutusScriptVersion
-    , actualVersion   :: AnyScriptLanguage
-    }
-
-  | BlueprintJsonError String
-  deriving stock (Show)
-
-makeClassyPrisms ''BlueprintError
-
-data LookupScriptFailure =
-  FailedToFindTransferScript BlueprintKey
-  | FailedToFindIssuanceScript BlueprintKey
-  deriving stock (Eq, Show)
-
-makeClassyPrisms ''LookupScriptFailure
 
 data AikenError era =
   ABlueprintError BlueprintError
diff --git a/src/examples/aiken/haskell/lib/Wst/Aiken/Offchain.hs b/src/examples/aiken/haskell/lib/Wst/Aiken/Offchain.hs
index 3020bd4b..2a67acaa 100644
--- a/src/examples/aiken/haskell/lib/Wst/Aiken/Offchain.hs
+++ b/src/examples/aiken/haskell/lib/Wst/Aiken/Offchain.hs
@@ -17,53 +17,11 @@ module Wst.Aiken.Offchain
   )
 where
 
-import Cardano.Api (ScriptInAnyLang)
 import Cardano.Api qualified as C
-import Control.Lens (review)
-import Control.Monad.Except (MonadError (..))
-import Data.Map qualified as Map
-import PlutusLedgerApi.V3 (CurrencySymbol)
+import Convex.Aiken.Offchain (Cip143Blueprint (..), blueprintKeys,
+                              extractV3Scripts_, lookupScripts, lookupScripts_)
 import ProgrammableTokens.OffChain.Env.TransferLogic (TransferLogicEnv (..))
-import Wst.Aiken.Blueprint (Blueprint (..))
-import Wst.Aiken.Blueprint qualified as Blueprint
-import Wst.Aiken.BlueprintKey (BlueprintKey)
-import Wst.Aiken.Error (AsBlueprintError (..), AsLookupScriptFailure (..),
-                        LookupScriptFailure (..))
-
-data Cip143Blueprint v
-  = Cip143Blueprint
-  { cbTransfer :: v,
-    cbIssuance :: v,
-    cbGlobalStateCS :: Maybe CurrencySymbol
-  } deriving stock (Eq, Show, Functor, Foldable, Traversable)
-
-blueprintKeys :: Cip143Blueprint BlueprintKey
-blueprintKeys =
-  Cip143Blueprint
-    { cbTransfer = "transfer.transfer.withdraw"
-    , cbIssuance = "transfer.issue.withdraw"
-    , cbGlobalStateCS = Nothing
-    }
-
--- | Lookup the scripts that are referenced in the CIP 143 blueprint
-lookupScripts :: Blueprint -> Cip143Blueprint BlueprintKey -> Either LookupScriptFailure (Cip143Blueprint ScriptInAnyLang)
-lookupScripts Blueprint {validators} b@Cip143Blueprint {cbTransfer, cbIssuance} = do
-  tr <- maybe (Left $ FailedToFindTransferScript cbTransfer) Right (Map.lookup cbTransfer validators)
-  i <- maybe (Left $ FailedToFindIssuanceScript cbIssuance) Right (Map.lookup cbIssuance validators)
-  pure $ b {cbIssuance = i, cbTransfer = tr}
-
--- | Lookup the scripts that are referenced in the CIP 143 blueprint
-lookupScripts_ :: (MonadError err m, AsLookupScriptFailure err) => Blueprint -> Cip143Blueprint BlueprintKey -> m (Cip143Blueprint ScriptInAnyLang)
-lookupScripts_ bp =
-  either (throwError . review _LookupScriptFailure) pure
-  .  lookupScripts bp
-
-getPlutus :: C.Script C.PlutusScriptV3 -> C.PlutusScript C.PlutusScriptV3
-getPlutus = \case
-  C.PlutusScript C.PlutusScriptV3 script -> script
-
-extractV3Scripts_ :: (MonadError err m, AsBlueprintError err) => Cip143Blueprint ScriptInAnyLang -> m (Cip143Blueprint (C.PlutusScript C.PlutusScriptV3))
-extractV3Scripts_ = traverse (fmap getPlutus . Blueprint.getPlutusV3)
+import Wst.Aiken.Error (AsLookupScriptFailure (..), LookupScriptFailure (..))
 
 transferLogic :: Cip143Blueprint (C.PlutusScript C.PlutusScriptV3) -> TransferLogicEnv
 transferLogic Cip143Blueprint{cbTransfer, cbIssuance, cbGlobalStateCS} =
diff --git a/src/examples/aiken/haskell/lib/Wst/Cli.hs b/src/examples/aiken/haskell/lib/Wst/Cli.hs
index 48a0b835..06c0d10b 100644
--- a/src/examples/aiken/haskell/lib/Wst/Cli.hs
+++ b/src/examples/aiken/haskell/lib/Wst/Cli.hs
@@ -5,7 +5,7 @@ module Wst.Cli(runMain) where
 import Blammo.Logging.Logger (flushLogger)
 import Blammo.Logging.Simple (Message ((:#)), MonadLogger, logError, logInfo,
                               runLoggerLoggingT, (.=))
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Lens qualified as L
 import Control.Monad.Error.Lens (throwing, throwing_)
 import Control.Monad.Except (MonadError)
diff --git a/src/examples/aiken/haskell/lib/Wst/Cli/Command.hs b/src/examples/aiken/haskell/lib/Wst/Cli/Command.hs
index 6e032420..8b3aff98 100644
--- a/src/examples/aiken/haskell/lib/Wst/Cli/Command.hs
+++ b/src/examples/aiken/haskell/lib/Wst/Cli/Command.hs
@@ -10,9 +10,10 @@ module Wst.Cli.Command(
 
 import Blammo.Logging.Simple (MonadLogger, logInfo)
 import Cardano.Api (AssetName, Quantity)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad.Except (MonadError (..))
 import Control.Monad.IO.Class (MonadIO (..))
+import Convex.Aiken.Blueprint qualified as Blueprint
 import Convex.Class qualified as Convex
 import Convex.Wallet.Operator (OperatorConfigSigning,
                                parseOperatorConfigSigning)
@@ -29,7 +30,6 @@ import Options.Applicative (CommandFields, Mod, Parser, argument, auto, command,
 import PlutusLedgerApi.V1 qualified as PV1
 import ProgrammableTokens.OffChain.Env.TransferLogic (TransferLogicEnv)
 import Text.Read (readEither)
-import Wst.Aiken.Blueprint qualified as Blueprint
 import Wst.Aiken.Error (AsBlueprintError, AsLookupScriptFailure)
 import Wst.Aiken.Offchain qualified as OffChain
 
diff --git a/src/examples/aiken/haskell/test/Wst/Aiken/Test.hs b/src/examples/aiken/haskell/test/Wst/Aiken/Test.hs
index 8bed2eb0..c6beb123 100644
--- a/src/examples/aiken/haskell/test/Wst/Aiken/Test.hs
+++ b/src/examples/aiken/haskell/test/Wst/Aiken/Test.hs
@@ -10,13 +10,14 @@ import Cardano.Api qualified as C
 import Control.Monad.Except (MonadError)
 import Control.Monad.IO.Class (MonadIO (..))
 import Control.Monad.Reader (runReaderT)
+import Convex.Aiken.Blueprint (Blueprint (..))
+import Convex.Aiken.Blueprint qualified as Blueprint
 import Convex.Class (MonadBlockchain, MonadUtxoQuery, sendTx)
 import Convex.CoinSelection (AsBalancingError, AsCoinSelectionError)
 import Convex.Wallet qualified as Wallet
 import Convex.Wallet.MockWallet qualified as Wallet
 import Convex.Wallet.Operator (signTxOperator)
 import Data.Functor (void)
-import Data.Map qualified as Map
 import Paths_aiken_example qualified as Pkg
 import ProgrammableTokens.OffChain.Endpoints qualified as Endpoints
 import ProgrammableTokens.OffChain.Env qualified as Env
@@ -25,9 +26,7 @@ import ProgrammableTokens.OffChain.Query qualified as Query
 import ProgrammableTokens.Test qualified as Test
 import SmartTokens.Core.Scripts (ScriptTarget (..))
 import Test.Tasty (TestTree, testGroup)
-import Test.Tasty.HUnit (Assertion, assertEqual, testCase, testCaseSteps)
-import Wst.Aiken.Blueprint (Blueprint (..))
-import Wst.Aiken.Blueprint qualified as Blueprint
+import Test.Tasty.HUnit (testCase, testCaseSteps)
 import Wst.Aiken.Error (AikenError, AsBlueprintError)
 import Wst.Aiken.Offchain qualified as Offchain
 
@@ -35,9 +34,7 @@ tests :: TestTree
 tests =
   testGroup
     "unit tests"
-    [ testCase "load blueprint" loadBlueprint,
-      testCase "deserialise script" deserialiseScript,
-      testGroup
+    [ testGroup
         "emulator"
         [ testCaseSteps "register"
             $ Test.mockchainSucceedsWithTarget @(AikenError C.ConwayEra) Debug . registerAikenPolicy
@@ -45,20 +42,6 @@ tests =
         ]
     ]
 
-loadBlueprint :: Assertion
-loadBlueprint = do
-  void loadExample
-
-deserialiseScript :: Assertion
-deserialiseScript = do
-  Blueprint {validators} <- loadExample
-  maybe (fail "Expected script named 'transfer.issue.withdraw'") pure (Map.lookup "transfer.issue.withdraw" validators)
-    >>= \case
-      (C.ScriptInAnyLang (C.PlutusScriptLanguage C.PlutusScriptV3) script) -> do
-        let hsh = C.hashScript script
-        assertEqual "Script hash" "0f8107a024cfbc7e5e787d67acddcec748ceb280fcc4b14c305e6a2d" hsh
-      _ -> fail "Unexpected script language"
-
 loadExample :: IO Blueprint
 loadExample = do
   Pkg.getDataFileName "data/aiken-scripts.json"
@@ -94,7 +77,7 @@ registerAikenPolicy step' = do
 
   step "Registering CIP 143 policy"
   runAsAdmin $ do
-    Endpoints.registerCip143PolicyTx "TEST" 1000 (100 :: Integer)
+    Endpoints.registerCip143PolicyTx (C.UnsafeAssetName "TEST") 1000 (100 :: Integer)
       >>= void . sendTx . signTxOperator Test.admin
 
     Query.registryNodes @C.ConwayEra
@@ -127,7 +110,7 @@ transferAikenPolicy = do
             >>= void . sendTx . signTxOperator Test.admin
 
   runAsAdmin $ do
-    Endpoints.registerCip143PolicyTx "TEST" 1000 (100 :: Integer)
+    Endpoints.registerCip143PolicyTx (C.UnsafeAssetName "TEST") 1000 (100 :: Integer)
       >>= void . sendTx . signTxOperator Test.admin
 
   let paymentCred = C.PaymentCredentialByKey (Wallet.verificationKeyHash Wallet.w2)
@@ -137,7 +120,7 @@ transferAikenPolicy = do
       >>= void . Test.expectN 0 "user programmable outputs"
 
   runAsAdmin $ do
-    Endpoints.transferTokens "TEST" 500 paymentCred (200 :: Integer)
+    Endpoints.transferTokens (C.UnsafeAssetName "TEST") 500 paymentCred (200 :: Integer)
       >>= void . sendTx . signTxOperator Test.admin
 
   runAsAdmin $
@@ -145,7 +128,7 @@ transferAikenPolicy = do
       >>= void . Test.expectN 1 "user programmable outputs"
 
   runAsAdmin $ do
-    Endpoints.transferTokens "TEST" 500 paymentCred (200 :: Integer)
+    Endpoints.transferTokens (C.UnsafeAssetName "TEST") 500 paymentCred (200 :: Integer)
       >>= void . sendTx . signTxOperator Test.admin
 
   runAsAdmin $
diff --git a/src/examples/regulated-stablecoin/exe/calculate-hashes/Main.hs b/src/examples/regulated-stablecoin/exe/calculate-hashes/Main.hs
index 86a4bfbb..b3fb9f0f 100644
--- a/src/examples/regulated-stablecoin/exe/calculate-hashes/Main.hs
+++ b/src/examples/regulated-stablecoin/exe/calculate-hashes/Main.hs
@@ -3,7 +3,7 @@
 -}
 module Main (main) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Cardano.Ledger.BaseTypes qualified as Ledger
 import Data.Aeson qualified as Aeson
 import Data.ByteString.Lazy qualified as BSL
@@ -29,7 +29,7 @@ main = System.Environment.getArgs >>= \case
     let transferLogicEnv = Env.mkTransferLogicEnv scriptRoot
         blacklistEnv     = Env.mkBlacklistEnv scriptRoot
 
-    printAssetId dirEnv transferLogicEnv "WST"
+    printAssetId dirEnv transferLogicEnv (C.UnsafeAssetName "WST")
     printTransferLogicAddress nid blacklistEnv
     printBaseCredential dirEnv
   _ -> do
diff --git a/src/examples/regulated-stablecoin/exe/convert-key/Main.hs b/src/examples/regulated-stablecoin/exe/convert-key/Main.hs
index 77f3fb5c..7804305e 100644
--- a/src/examples/regulated-stablecoin/exe/convert-key/Main.hs
+++ b/src/examples/regulated-stablecoin/exe/convert-key/Main.hs
@@ -6,7 +6,6 @@ module Main (
 
 import Cardano.Api qualified as C
 import Convex.Wallet.Operator qualified as Operator
-import Data.Proxy (Proxy (..))
 import Data.Text qualified as Text
 import System.Environment qualified
 import System.Exit (exitFailure)
@@ -15,7 +14,7 @@ main :: IO ()
 main = System.Environment.getArgs >>= \case
   [fp] -> do
     putStrLn $ "Reading extended signing key from " <> fp
-    C.readFileTextEnvelope (C.proxyToAsType $ Proxy @(C.SigningKey C.PaymentExtendedKey)) (C.File fp) >>= \case
+    C.readFileTextEnvelope (C.File fp) >>= \case
       Left err -> do
         putStrLn $ show err
         exitFailure
diff --git a/src/examples/regulated-stablecoin/exe/export-smart-tokens/Main.hs b/src/examples/regulated-stablecoin/exe/export-smart-tokens/Main.hs
index fadbf402..e3867a01 100644
--- a/src/examples/regulated-stablecoin/exe/export-smart-tokens/Main.hs
+++ b/src/examples/regulated-stablecoin/exe/export-smart-tokens/Main.hs
@@ -3,7 +3,7 @@
 module Main (main) where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Cardano.Binary qualified as CBOR
 import Control.Monad (when)
 import Control.Monad.IO.Class
@@ -67,17 +67,17 @@ import Wst.Server.Types (SerialiseAddress (..))
 encodeSerialiseCBOR :: Script -> Text
 encodeSerialiseCBOR = Text.decodeUtf8 . Base16.encode . CBOR.serialize' . serialiseScript
 
-evalT :: Config -> ClosedTerm a -> Either Text (Script, ExBudget, [Text])
+evalT :: Config -> (forall s. Term s a) -> Either Text (Script, ExBudget, [Text])
 evalT cfg x = evalWithArgsT cfg x []
 
-evalWithArgsT :: Config -> ClosedTerm a -> [Data] -> Either Text (Script, ExBudget, [Text])
+evalWithArgsT :: Config -> (forall s. Term s a) -> [Data] -> Either Text (Script, ExBudget, [Text])
 evalWithArgsT cfg x args = do
   cmp <- compile cfg x
   let (escr, budg, trc) = evalScript $ applyArguments cmp args
   scr <- first (pack . show) escr
   pure (scr, budg, trc)
 
-writePlutusScript :: Config -> String -> FilePath -> ClosedTerm a -> IO ()
+writePlutusScript :: Config -> String -> FilePath -> (forall s. Term s a) -> IO ()
 writePlutusScript cfg title filepath term = do
   case evalT cfg term of
     Left e -> print e
@@ -96,13 +96,13 @@ _writePlutusScriptWithArgs title filepath args compiledScript = do
       content = encodePretty plutusJson
   LBS.writeFile filepath content
 
-writePlutusScriptTraceBind :: String -> FilePath -> ClosedTerm a -> IO ()
+writePlutusScriptTraceBind :: String -> FilePath -> (forall s. Term s a) -> IO ()
 writePlutusScriptTraceBind = writePlutusScript (Tracing LogInfo DoTracingAndBinds)
 
-writePlutusScriptTrace :: String -> FilePath -> ClosedTerm a -> IO ()
+writePlutusScriptTrace :: String -> FilePath -> (forall s. Term s a) -> IO ()
 writePlutusScriptTrace = writePlutusScript (Tracing LogInfo DoTracing)
 
-writePlutusScriptNoTrace :: String -> FilePath -> ClosedTerm a -> IO ()
+writePlutusScriptNoTrace :: String -> FilePath -> (forall s. Term s a) -> IO ()
 writePlutusScriptNoTrace = writePlutusScript NoTracing
 
 issuerPrefixPostfixBytes :: V3.Credential -> (Text, Text)
@@ -286,16 +286,5 @@ parseAddress = argument (eitherReader (eitherDecode . LBS8.pack)) (help "The add
 parseIssuerTxIn :: Parser C.TxIn
 parseIssuerTxIn =
   argument
-    txInReader
+    Cli.Command.txInReader
     (help "The reference utxo with the prefix and postfix cborhex of the issuance script. Format: <tx-id>.<index>" <> metavar "ISSUER_TX_IN")
-
-txInReader :: ReadM C.TxIn
-txInReader = eitherReader $ \str -> do
-  (txId, txIx) <- case break (== '.') str of
-    (txId, _:txIx) -> Right (txId, txIx)
-    _ -> Left "Expected <tx-id>.<index>"
-  when (length txId /= 64) $ Left "Expected tx ID with 64 characters"
-  ix <- case readMaybe @Word txIx of
-          Nothing -> Left "Expected tx index"
-          Just n -> Right (C.TxIx n)
-  return $ C.TxIn (fromString txId) ix
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Cli.hs b/src/examples/regulated-stablecoin/lib/Wst/Cli.hs
index 02bebcc5..dc0a469f 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Cli.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Cli.hs
@@ -17,7 +17,6 @@ import Convex.Wallet.Operator (Operator (Operator, oPaymentKey),
                                verificationKey)
 import Convex.Wallet.Operator qualified as Operator
 import Data.Maybe (fromMaybe)
-import Data.Proxy (Proxy (..))
 import Data.String (IsString (..))
 import Options.Applicative (customExecParser, disambiguate, helper, idm, info,
                             prefs, showHelpOnEmpty, showHelpOnError)
@@ -68,7 +67,7 @@ deploy config = do
   -- _operator <- liftIO (Operator.loadOperatorFiles config)
 
   signingKey <- liftIO
-    $ C.readFileTextEnvelope (C.proxyToAsType $ Proxy @(C.SigningKey C.PaymentExtendedKey)) (C.File $ Operator.ocSigningKeyFile config)
+    $ C.readFileTextEnvelope (C.File $ Operator.ocSigningKeyFile config)
     >>= either (error . show) pure
 
   let operator = Operator (PESigningEx signingKey) Nothing
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Cli/Command.hs b/src/examples/regulated-stablecoin/lib/Wst/Cli/Command.hs
index 88917c54..824d6cc0 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Cli/Command.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Cli/Command.hs
@@ -6,14 +6,16 @@ module Wst.Cli.Command(
   ManageCommand(..),
 
   -- * Other parsers
-  parseTxIn
+  parseTxIn,
+  txInReader,
 ) where
 
-import Cardano.Api (TxIn (..), TxIx (..))
+import Cardano.Api (TxIn (..), TxIx (..), parseTxId)
+import Cardano.Api.Parser.Text qualified as Parser
 import Control.Monad (when)
 import Convex.Wallet.Operator (OperatorConfigSigning,
                                parseOperatorConfigSigning)
-import Data.String (IsString (..))
+import Data.Text qualified as Text
 import Options.Applicative (CommandFields, Mod, Parser, ReadM, argument, auto,
                             command, eitherReader, fullDesc, help, info, long,
                             metavar, option, optional, progDesc, short,
@@ -86,4 +88,5 @@ txInReader = eitherReader $ \str -> do
   ix <- case readMaybe @Word txIx of
           Nothing -> Left "Expected tx index"
           Just n -> Right (TxIx n)
-  return $ TxIn (fromString txId) ix
+  txId' <- Parser.runParser parseTxId (Text.pack txId)
+  return $ TxIn txId' ix
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ExampleTransfer.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ExampleTransfer.hs
index b1180fcd..9b8479b8 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ExampleTransfer.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ExampleTransfer.hs
@@ -7,7 +7,7 @@ module Wst.Offchain.ExampleTransfer (
   where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Control.Lens (over)
 import Convex.BuildTx (MonadBuildTx, addBtx, addReference,
                        addStakeScriptWitness, addWithdrawalWithTxBody,
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Failing.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Failing.hs
index 4faae6e6..3e7b2cea 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Failing.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Failing.hs
@@ -11,8 +11,8 @@ module Wst.Offchain.BuildTx.Failing(
   balanceTxEnvFailing
 ) where
 
+import Cardano.Api qualified as C
 import Cardano.Api.Experimental (IsEra)
-import Cardano.Api.Shelley qualified as C
 import Control.Lens (set)
 import Control.Monad.Error.Lens (throwing, throwing_)
 import Control.Monad.Except (MonadError)
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ProgrammableLogic.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ProgrammableLogic.hs
index 5e2673d9..deef2ffc 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ProgrammableLogic.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/ProgrammableLogic.hs
@@ -11,7 +11,7 @@ module Wst.Offchain.BuildTx.ProgrammableLogic
 where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Control.Lens ((^.))
 import Control.Monad.Reader (MonadReader, asks)
 import Convex.BuildTx (MonadBuildTx, addReference, addWithdrawalWithTxBody,
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/TransferLogic.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/TransferLogic.hs
index d3653fbe..46fdeb36 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/TransferLogic.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/TransferLogic.hs
@@ -18,8 +18,7 @@ module Wst.Offchain.BuildTx.TransferLogic
 where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
-import Control.Lens (at, over, set, (&), (?~), (^.))
+import Control.Lens (_1, at, over, set, (&), (?~), (^.))
 import Control.Monad (when)
 import Control.Monad.Error.Lens (throwing_)
 import Control.Monad.Except (MonadError)
@@ -84,7 +83,7 @@ initBlacklist = Utils.inBabbage @era $ do
 
   -- mint blacklist policy token
   mintingScript <- asks (Env.bleMintingScript . Env.blacklistEnv)
-  let assetName = C.AssetName ""
+  let assetName = C.UnsafeAssetName ""
       quantity = 1
 
   mintPlutus mintingScript () assetName quantity
@@ -125,7 +124,7 @@ insertBlacklistNode :: forall era env err m. (MonadReader env m, Env.HasOperator
 insertBlacklistNode reason cred blacklistNodes = Utils.inBabbage @era $ do
   -- mint new blacklist token
   mintingScript <- asks (Env.bleMintingScript . Env.blacklistEnv)
-  let newAssetName = C.AssetName $  case transCredential cred of
+  let newAssetName = C.UnsafeAssetName $  case transCredential cred of
                         PubKeyCredential (PubKeyHash s) -> PlutusTx.fromBuiltin s
                         ScriptCredential (ScriptHash s) -> PlutusTx.fromBuiltin s
       quantity = 1
@@ -177,7 +176,7 @@ removeBlacklistNode cred blacklistNodes = Utils.inBabbage @era $ do
     <- maybe (throwing_ _BlacklistNodeNotFound) pure $ find ((== unwrapCredential (transCredential cred)) . blnKey . uDatum) blacklistNodes
 
 
-  let expectedAssetName = C.AssetName $  case transCredential cred of
+  let expectedAssetName = C.UnsafeAssetName $  case transCredential cred of
         PubKeyCredential (PubKeyHash s) -> PlutusTx.fromBuiltin s
         ScriptCredential (ScriptHash s) -> PlutusTx.fromBuiltin s
 
@@ -388,7 +387,7 @@ addTransferWitness blacklistNodes = Utils.inBabbage @era $ do
 
 addReferencesWithTxBody :: (MonadBuildTx era m, C.IsBabbageBasedEra era) => (C.TxBodyContent C.BuildTx era -> [C.TxIn]) -> m ()
 addReferencesWithTxBody f =
-  addTxBuilder (TxBuilder $ \body -> over (L.txInsReference . L._TxInsReferenceIso) (nub . (f body <>)))
+  addTxBuilder (TxBuilder $ \body -> over (L.txInsReference . L._TxInsReferenceIso . _1) (nub . (f body <>)))
 
 addSeizeWitness :: forall env era m. (MonadReader env m, Env.HasOperatorEnv era env, Env.HasTransferLogicEnv env, C.IsBabbageBasedEra era, MonadBlockchain era m, C.HasScriptLanguageInEra C.PlutusScriptV3 era, MonadBuildTx era m) => m ()
 addSeizeWitness = Utils.inBabbage @era $ do
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Utils.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Utils.hs
index 8fb1ce7f..65c47426 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Utils.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/BuildTx/Utils.hs
@@ -5,7 +5,7 @@ module Wst.Offchain.BuildTx.Utils
 
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Cardano.Ledger.Shelley.TxCert qualified as TxCert
 import Convex.BuildTx (MonadBuildTx, addCertificate)
 
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/Endpoints/Deployment.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/Endpoints/Deployment.hs
index 6abd983b..3f4a758f 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/Endpoints/Deployment.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/Endpoints/Deployment.hs
@@ -12,7 +12,7 @@ module Wst.Offchain.Endpoints.Deployment(
 ) where
 
 import Cardano.Api (Quantity)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad (when)
 import Control.Monad.Error.Lens (throwing_)
 import Control.Monad.Except (MonadError (..))
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Offchain/Scripts.hs b/src/examples/regulated-stablecoin/lib/Wst/Offchain/Scripts.hs
index b1da875e..33d8fe75 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Offchain/Scripts.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Offchain/Scripts.hs
@@ -16,7 +16,7 @@ module Wst.Offchain.Scripts (
   where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Convex.PlutusLedger.V1 (transCredential, transPolicyId, transPubKeyHash)
 import Convex.PlutusLedger.V3 (transTxOutRef)
 import Plutarch.Prelude
@@ -41,7 +41,7 @@ issuanceCborHexMintingScript target txIn =
 -- | The spending script for the issuance cbor hex NFT parameterized by the nonce "deadbeef"
 issuanceCborHexSpendingScript :: ScriptTarget -> C.PlutusScript C.PlutusScriptV3
 issuanceCborHexSpendingScript target =
-  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "deadbeef" :: ClosedTerm PByteString))
+  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "deadbeef" :: Term s PByteString))
   in C.PlutusScriptSerialised $ serialiseScript script
 
 freezeTransferScript :: ScriptTarget -> C.PaymentCredential -> C.PolicyId -> C.PlutusScript C.PlutusScriptV3
@@ -59,20 +59,20 @@ alwaysSucceedsScript target =
 
 permissionedMintingScript :: ScriptTarget -> C.Hash C.PaymentKey -> C.PlutusScript C.PlutusScriptV3
 permissionedMintingScript target cred =
-  let script = Scripts.tryCompile target $ mkPermissionedMinting # pforgetData (pdata (pconstant "permissioned minting" :: ClosedTerm PByteString)) # pdata (pconstant $ transPubKeyHash cred)
+  let script = Scripts.tryCompile target $ mkPermissionedMinting # pforgetData (pdata (pconstant "permissioned minting" :: Term s PByteString)) # pdata (pconstant $ transPubKeyHash cred)
   in C.PlutusScriptSerialised $ serialiseScript script
 
 permissionedSpendingScript :: ScriptTarget -> C.Hash C.PaymentKey -> C.PlutusScript C.PlutusScriptV3
 permissionedSpendingScript target cred =
-  let script = Scripts.tryCompile target $ mkPermissionedTransfer # pforgetData (pdata (pconstant "permissioned spending" :: ClosedTerm PByteString)) # pdata (pconstant $ transPubKeyHash cred)
+  let script = Scripts.tryCompile target $ mkPermissionedTransfer # pforgetData (pdata (pconstant "permissioned spending" :: Term s PByteString)) # pdata (pconstant $ transPubKeyHash cred)
   in C.PlutusScriptSerialised $ serialiseScript script
 
 blacklistMintingScript :: ScriptTarget -> C.Hash C.PaymentKey -> C.PlutusScript C.PlutusScriptV3
 blacklistMintingScript target cred =
-  let script = Scripts.tryCompile target $ mkPermissionedMinting # pforgetData (pdata (pconstant "blacklist minting" :: ClosedTerm PByteString)) # pdata (pconstant $ transPubKeyHash cred)
+  let script = Scripts.tryCompile target $ mkPermissionedMinting # pforgetData (pdata (pconstant "blacklist minting" :: Term s PByteString)) # pdata (pconstant $ transPubKeyHash cred)
   in C.PlutusScriptSerialised $ serialiseScript script
 
 blacklistSpendingScript :: ScriptTarget -> C.Hash C.PaymentKey -> C.PlutusScript C.PlutusScriptV3
 blacklistSpendingScript target cred =
-  let script = Scripts.tryCompile target $ mkPermissionedTransfer # pforgetData (pdata (pconstant "blacklist spending" :: ClosedTerm PByteString)) # pdata (pconstant $ transPubKeyHash cred)
+  let script = Scripts.tryCompile target $ mkPermissionedTransfer # pforgetData (pdata (pconstant "blacklist spending" :: Term s PByteString)) # pdata (pconstant $ transPubKeyHash cred)
   in C.PlutusScriptSerialised $ serialiseScript script
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Server.hs b/src/examples/regulated-stablecoin/lib/Wst/Server.hs
index 852cc141..e810f989 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Server.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Server.hs
@@ -16,7 +16,7 @@ module Wst.Server(
 import Blammo.Logging.Simple (HasLogger, Message ((:#)), MonadLogger, logInfo,
                               (.=))
 import Blockfrost.Client.Types qualified as Blockfrost
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Lens qualified as L
 import Control.Monad.Error.Class (MonadError (throwError))
 import Control.Monad.IO.Class (MonadIO (..))
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Server/DemoEnvironment.hs b/src/examples/regulated-stablecoin/lib/Wst/Server/DemoEnvironment.hs
index 3849920e..303ce5eb 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Server/DemoEnvironment.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Server/DemoEnvironment.hs
@@ -13,7 +13,7 @@ module Wst.Server.DemoEnvironment(
   writeToFile,
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Cardano.Ledger.BaseTypes qualified as Ledger
 import Control.Lens ((&), (?~))
 import Data.Aeson (FromJSON (..), ToJSON (..))
@@ -129,7 +129,7 @@ mkDemoEnv txIn issuanceCborHexTxIn (C.ShelleyAddress network (C.fromShelleyPayme
       transferLogicEnv = Env.mkTransferLogicEnv rt
       blacklistEnv     = Env.mkBlacklistEnv rt
       dummyText        = "REPLACE ME"
-      assetName        = "WST"
+      assetName        = C.UnsafeAssetName "WST"
       dummyBlockfrostUrl = "https://cardano-preview.blockfrost.io/api/v0"
       dummyNetwork     = Preview
       dummyKey = "REPLACE ME"
diff --git a/src/examples/regulated-stablecoin/lib/Wst/Server/Types.hs b/src/examples/regulated-stablecoin/lib/Wst/Server/Types.hs
index 2ad26a01..9fc974f7 100644
--- a/src/examples/regulated-stablecoin/lib/Wst/Server/Types.hs
+++ b/src/examples/regulated-stablecoin/lib/Wst/Server/Types.hs
@@ -61,7 +61,7 @@ instance C.HasTextEnvelope a => ToJSON (TextEnvelopeJSON a) where
   toJSON = toJSON . C.serialiseToTextEnvelope Nothing . unTextEnvelopeJSON
 
 instance C.HasTextEnvelope a => FromJSON (TextEnvelopeJSON a) where
-  parseJSON val = parseJSON val >>= either (fail . show) (pure . TextEnvelopeJSON) . C.deserialiseFromTextEnvelope (C.proxyToAsType Proxy)
+  parseJSON val = parseJSON val >>= either (fail . show) (pure . TextEnvelopeJSON) . C.deserialiseFromTextEnvelope
 
 instance C.HasTextEnvelope a => ToSchema (TextEnvelopeJSON a) where
   declareNamedSchema _ = pure
diff --git a/src/examples/regulated-stablecoin/test/unit/Wst/Test/Env.hs b/src/examples/regulated-stablecoin/test/unit/Wst/Test/Env.hs
index 32c05f4e..2e1a1e39 100644
--- a/src/examples/regulated-stablecoin/test/unit/Wst/Test/Env.hs
+++ b/src/examples/regulated-stablecoin/test/unit/Wst/Test/Env.hs
@@ -8,7 +8,7 @@ module Wst.Test.Env(
   user,
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad.Reader (MonadReader, ReaderT)
 import Convex.Class (MonadUtxoQuery)
 import Convex.Wallet qualified as Wallet
diff --git a/src/examples/regulated-stablecoin/test/unit/Wst/Test/UnitTest.hs b/src/examples/regulated-stablecoin/test/unit/Wst/Test/UnitTest.hs
index 646ef01a..4d1c4620 100644
--- a/src/examples/regulated-stablecoin/test/unit/Wst/Test/UnitTest.hs
+++ b/src/examples/regulated-stablecoin/test/unit/Wst/Test/UnitTest.hs
@@ -4,7 +4,6 @@ module Wst.Test.UnitTest(
 ) where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
 import Control.Monad (void)
 import Control.Monad.Except (MonadError)
 import Control.Monad.Reader (MonadReader (ask), ReaderT (runReaderT), asks)
@@ -90,7 +89,7 @@ issueTransferLogicProgrammableToken scriptRoot = Env.withEnv $ do
   asAdmin @C.ConwayEra $ Env.withDirectoryFor scriptRoot $ Env.withTransferFromOperator @C.ConwayEra $ do
     opPkh <- asks (fst . Env.bteOperator . Env.operatorEnv @C.ConwayEra)
 
-    (balTx, aid) <- Endpoints.issueSmartTokensTx "dummy asset" 100 (C.PaymentCredentialByKey opPkh)
+    (balTx, aid) <- Endpoints.issueSmartTokensTx (C.UnsafeAssetName "dummy asset") 100 (C.PaymentCredentialByKey opPkh)
     void $ sendTx $ signTxOperator admin balTx
 
     Query.registryNodes @C.ConwayEra
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Directory.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Directory.hs
index bd8b146c..06baa748 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Directory.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Directory.hs
@@ -7,7 +7,8 @@ module ProgrammableTokens.OffChain.BuildTx.Directory
   )
 where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
+import Cardano.Api.Value qualified as C
 import Control.Monad.Reader (MonadReader, asks)
 import Convex.BuildTx (MonadBuildTx, addReference, mintPlutus, prependTxOut,
                        spendPlutusInlineDatum)
@@ -88,7 +89,7 @@ insertDirectoryNode UTxODat {uIn = paramsRef} UTxODat {uIn = issuanceCborHexRef}
 
       newTokenName =
         let CurrencySymbol s = inaNewKey
-         in C.AssetName $ PlutusTx.fromBuiltin s
+         in C.UnsafeAssetName $ PlutusTx.fromBuiltin s
 
       newVal =
         C.TxOutValueShelleyBased C.shelleyBasedEra $
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/IssuanceCborHexRef.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/IssuanceCborHexRef.hs
index 1fe04643..dc77894d 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/IssuanceCborHexRef.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/IssuanceCborHexRef.hs
@@ -6,7 +6,6 @@ module ProgrammableTokens.OffChain.BuildTx.IssuanceCborHexRef (
 ) where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
 import Control.Monad.Reader (MonadReader, asks)
 import Convex.BuildTx (MonadBuildTx, mintPlutus, prependTxOut,
                        spendPublicKeyOutput)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProgrammableLogic.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProgrammableLogic.hs
index 633749d6..31d60168 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProgrammableLogic.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProgrammableLogic.hs
@@ -9,7 +9,7 @@ module ProgrammableTokens.OffChain.BuildTx.ProgrammableLogic(
   transferProgrammableToken
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad (unless)
 import Control.Monad.Reader (MonadReader, asks)
 import Convex.BuildTx (MonadBuildTx, mintPlutus, payToAddress)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProtocolParams.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProtocolParams.hs
index 7d556874..d716345f 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProtocolParams.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/ProtocolParams.hs
@@ -5,7 +5,6 @@ module ProgrammableTokens.OffChain.BuildTx.ProtocolParams(
 ) where
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
 import Control.Monad.Reader (MonadReader, asks)
 import Convex.BuildTx (MonadBuildTx, mintPlutus, prependTxOut,
                        spendPublicKeyOutput)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Utils.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Utils.hs
index d2335b59..cf2e8dd6 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Utils.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/BuildTx/Utils.hs
@@ -5,7 +5,6 @@ module ProgrammableTokens.OffChain.BuildTx.Utils
 
 
 import Cardano.Api qualified as C
-import Cardano.Api.Shelley qualified as C
 import Cardano.Ledger.Shelley.TxCert qualified as TxCert
 import Convex.BuildTx (MonadBuildTx, addCertificate)
 
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Directory.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Directory.hs
index 5c2826b5..3648b66d 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Directory.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Directory.hs
@@ -23,7 +23,7 @@ module ProgrammableTokens.OffChain.Env.Directory(
 ) where
 
 import Cardano.Api (PlutusScript, PlutusScriptV3)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Lens qualified as L
 import Control.Monad.Except (MonadError)
 import Control.Monad.Reader (MonadReader, asks)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Operator.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Operator.hs
index 9167afca..0c773bc0 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Operator.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Operator.hs
@@ -21,7 +21,7 @@ module ProgrammableTokens.OffChain.Env.Operator(
 ) where
 
 import Cardano.Api (UTxO)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad.Error.Lens (throwing_)
 import Control.Monad.Except (MonadError)
 import Control.Monad.Reader (MonadReader, ReaderT, asks)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Runtime.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Runtime.hs
index 253a127b..213b4bf7 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Runtime.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/Runtime.hs
@@ -19,7 +19,7 @@ import Blammo.Logging.Logger (HasLogger (..), newLogger)
 import Blammo.Logging.LogSettings.Env qualified as LogSettingsEnv
 import Blockfrost.Auth (mkProject)
 import Blockfrost.Client.Auth qualified as Blockfrost
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Lens (makeLensesFor)
 import Control.Lens qualified as L
 import Data.HSet.Get (HGettable)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/TransferLogic.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/TransferLogic.hs
index 6c608f5b..95c257c5 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/TransferLogic.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Env/TransferLogic.hs
@@ -10,7 +10,7 @@ module ProgrammableTokens.OffChain.Env.TransferLogic(
 ) where
 
 import Cardano.Api (PlutusScript, PlutusScriptV3)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad.Reader (MonadReader (..), asks)
 import Convex.PlutusLedger.V1 (unTransCredential)
 import Data.Either (fromRight)
diff --git a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Scripts.hs b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Scripts.hs
index 998c5092..9ebd2926 100644
--- a/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Scripts.hs
+++ b/src/programmable-tokens-offchain/lib/ProgrammableTokens/OffChain/Scripts.hs
@@ -21,13 +21,12 @@ module ProgrammableTokens.OffChain.Scripts(
   scriptPolicyIdV3
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Convex.PlutusLedger.V1 (transCredential, transPolicyId,
                                transStakeCredential)
 import Convex.PlutusLedger.V3 (transTxOutRef)
 import Plutarch.Evaluate (applyArguments)
-import Plutarch.Prelude (ClosedTerm, PByteString, pconstant, pdata, pforgetData,
-                         (#))
+import Plutarch.Prelude (PByteString, Term, pconstant, pdata, pforgetData, (#))
 import Plutarch.Script (serialiseScript)
 import PlutusLedgerApi.V3 (Credential (..), ScriptHash, toData)
 import SmartTokens.Contracts.AlwaysYields (palwaysSucceed)
@@ -53,7 +52,7 @@ protocolParamsMintingScript target txIn =
 -- nonce
 protocolParamsSpendingScript :: ScriptTarget -> C.PlutusScript C.PlutusScriptV3
 protocolParamsSpendingScript target =
-  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "" :: ClosedTerm PByteString))
+  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "" :: Term s PByteString))
   in C.PlutusScriptSerialised $ serialiseScript script
 
 -- | The minting script for the issuance cbor hex NFT, takes initial TxIn for
@@ -66,7 +65,7 @@ issuanceCborHexMintingScript target txIn =
 -- | The spending script for the issuance cbor hex NFT parameterized by the nonce "deadbeef"
 issuanceCborHexSpendingScript :: ScriptTarget -> C.PlutusScript C.PlutusScriptV3
 issuanceCborHexSpendingScript target =
-  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "deadbeef" :: ClosedTerm PByteString))
+  let script = Scripts.tryCompile target $ alwaysFailScript # pforgetData (pdata (pconstant "deadbeef" :: Term s PByteString))
   in C.PlutusScriptSerialised $ serialiseScript script
 
 -- | The minting script for the directory node tokens, takes initial TxIn for
diff --git a/src/programmable-tokens-onchain/lib/Profile.hs b/src/programmable-tokens-onchain/lib/Profile.hs
index 427ecd6a..def509e6 100644
--- a/src/programmable-tokens-onchain/lib/Profile.hs
+++ b/src/programmable-tokens-onchain/lib/Profile.hs
@@ -13,17 +13,17 @@ import Plutarch.Internal.Other (printTerm)
 import Plutarch.Internal.Term
 import PlutusCore.Evaluation.Machine.ExBudget (ExBudget)
 
-getTracesExUnits :: ClosedTerm a -> [Text]
+getTracesExUnits :: (forall s. Term s a) -> [Text]
 getTracesExUnits term =
   let (_, _, traces) = fromRight (error "") (evalTerm (Tracing LogInfo DoTracingAndBinds) term)
   in traces
 
-getExUnits :: ClosedTerm a -> ExBudget
+getExUnits :: (forall s. Term s a) -> ExBudget
 getExUnits term =
   let (_, budget, _) = fromRight (error "") (evalTerm NoTracing term)
   in budget
 
-getShowTerm :: ClosedTerm a -> String
+getShowTerm :: (forall s. Term s a) -> String
 getShowTerm term =
   let (t, _, _) = fromRight (error "") (evalTerm NoTracing term)
   in
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/CodeLens.hs b/src/programmable-tokens-onchain/lib/SmartTokens/CodeLens.hs
index 7fe1577c..0e910a3f 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/CodeLens.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/CodeLens.hs
@@ -21,5 +21,5 @@ import Plutarch.Internal.Term qualified as PI
 --
 -- >>> _printTerm (pconstant $ BlacklistNode { blnKey = "a hi", blnNext = "a" })
 -- "program 1.0.0 (List [B #61206869, B #61])"
-_printTerm :: HasCallStack => ClosedTerm a -> String
+_printTerm :: HasCallStack => (forall s. Term s a) -> String
 _printTerm term = printScript $ either (error . T.unpack) id $ PI.compile PI.NoTracing term
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/AlwaysYields.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/AlwaysYields.hs
index c9007083..040f3b12 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/AlwaysYields.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/AlwaysYields.hs
@@ -5,9 +5,9 @@ module SmartTokens.Contracts.AlwaysYields(
 ) where
 
 import Plutarch.LedgerApi.V3 (PScriptContext)
-import Plutarch.Prelude (ClosedTerm, PUnit, pconstant, plam, (:-->))
+import Plutarch.Prelude (PUnit, Term, pconstant, plam, (:-->))
 
 {-| Validator that always succeeds
 -}
-palwaysSucceed :: ClosedTerm (PScriptContext :--> PUnit)
+palwaysSucceed :: Term s (PScriptContext :--> PUnit)
 palwaysSucceed = plam (const $ pconstant ())
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ExampleTransferLogic.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ExampleTransferLogic.hs
index bd2a1089..df81b4ee 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ExampleTransferLogic.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ExampleTransferLogic.hs
@@ -63,7 +63,7 @@ deriving via DeriveDataPLiftable PBlacklistProof BlacklistProof
 
   This ensures that only transactions signed by the specified permissioned credential can spend the associated programmable tokens.
 -}
-mkPermissionedTransfer :: ClosedTerm (PData :--> PAsData PPubKeyHash :--> PScriptContext :--> PUnit)
+mkPermissionedTransfer :: Term s (PData :--> PAsData PPubKeyHash :--> PScriptContext :--> PUnit)
 mkPermissionedTransfer = plam $ \_ permissionedCred ctx ->
   pvalidateConditions
     [ ptxSignedByPkh # permissionedCred # (pfromData . ptxInfoSignatories . pscriptContextTxInfo) ctx
@@ -165,7 +165,7 @@ pextractRequiredWitnesses = phoistAcyclic $ plam $ \progBaseCred inputs ->
      the blacklist proofs (provided via the redeemer) verifying the correctness of each proof
      (i.e. that the proof really does prove that the associated witness is not in the blacklist).
 -}
-mkFreezeAndSeizeTransfer :: ClosedTerm (PAsData PCredential :--> PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
+mkFreezeAndSeizeTransfer :: Term s (PAsData PCredential :--> PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
 mkFreezeAndSeizeTransfer = plam $ \(pfromData -> programmableLogicBaseCred) blacklistNodeCS ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'redeemer, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'inputs, ptxInfo'referenceInputs} <- pmatch pscriptContext'txInfo
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/Issuance.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/Issuance.hs
index 581283f3..7b50e4af 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/Issuance.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/Issuance.hs
@@ -93,7 +93,7 @@ Each programmable token entry is represented in a directory with the following a
 @mintingLogicCred@ Script Credential for the script which must be invoked to perform minting/burning operations
 @ctx@ Script context containing transaction details
 -}
-mkProgrammableLogicMinting :: ClosedTerm (PAsData PCredential :--> PAsData PScriptHash :--> PScriptContext :--> PUnit)
+mkProgrammableLogicMinting :: Term s (PAsData PCredential :--> PAsData PScriptHash :--> PScriptContext :--> PUnit)
 mkProgrammableLogicMinting = plam $ \(pfromData -> programmableLogicBase) mintingLogicCred' ctx -> P.do
   let mintingLogicCred = pdata $ pcon $ PScriptCredential mintingLogicCred'
   PScriptContext {pscriptContext'txInfo, pscriptContext'redeemer, pscriptContext'scriptInfo} <- pmatch ctx
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/IssuanceCborHex.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/IssuanceCborHex.hs
index 1fc2b59d..725c51e3 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/IssuanceCborHex.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/IssuanceCborHex.hs
@@ -57,7 +57,7 @@ data PIssuanceCborHex (s :: S)
 deriving via DeriveDataPLiftable (PAsData PIssuanceCborHex) IssuanceCborHex
   instance PLiftable PIssuanceCborHex
 
-mkIssuanceCborHexMinting :: ClosedTerm (PAsData PTxOutRef :--> PScriptContext :--> PUnit)
+mkIssuanceCborHexMinting :: Term s (PAsData PTxOutRef :--> PScriptContext :--> PUnit)
 mkIssuanceCborHexMinting = plam $ \oref ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'inputs, ptxInfo'mint} <- pmatch pscriptContext'txInfo
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProgrammableLogicBase.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProgrammableLogicBase.hs
index 34be9b1a..dc2bf7b8 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProgrammableLogicBase.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProgrammableLogicBase.hs
@@ -82,7 +82,7 @@ deriving via DeriveDataPLiftable PTokenProof TokenProof
 emptyValue :: Value
 emptyValue = mempty
 
-pemptyLedgerValue :: ClosedTerm (PValue 'Sorted 'Positive)
+pemptyLedgerValue :: Term s (PValue 'Sorted 'Positive)
 pemptyLedgerValue = punsafeCoerce $ pconstant @(PValue 'Unsorted 'NoGuarantees) emptyValue
 
 pvalueFromCred :: Term s (PCredential :--> PBuiltinList (PAsData PPubKeyHash) :--> PBuiltinList (PAsData PByteString) :--> PBuiltinList (PAsData PTxInInfo) :--> PValue 'Sorted 'Positive)
@@ -140,7 +140,7 @@ pvalueToCred = phoistAcyclic $ plam $ \cred inputs ->
 -- | Programmable logic base
 -- This validator forwards its validation logic to the programmable logic stake script
 -- using the withdraw-zero design pattern.
-mkProgrammableLogicBase :: ClosedTerm (PAsData PCredential :--> PScriptContext :--> PUnit)
+mkProgrammableLogicBase :: Term s (PAsData PCredential :--> PScriptContext :--> PUnit)
 mkProgrammableLogicBase = plam $ \stakeCred ctx ->
   pmatch (pscriptContextTxInfo ctx) $ \txInfo ->
     let wdrls :: Term _ (PBuiltinList (PBuiltinPair (PAsData PCredential) (PAsData PLovelace)))
@@ -249,7 +249,7 @@ data PProgrammableLogicGlobalRedeemer (s :: S)
 deriving via DeriveDataPLiftable PProgrammableLogicGlobalRedeemer ProgrammableLogicGlobalRedeemer
   instance PLiftable PProgrammableLogicGlobalRedeemer
 
-mkProgrammableLogicGlobal :: ClosedTerm (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
+mkProgrammableLogicGlobal :: Term s (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
 mkProgrammableLogicGlobal = plam $ \protocolParamsCS ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'redeemer, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'inputs, ptxInfo'referenceInputs, ptxInfo'outputs, ptxInfo'signatories, ptxInfo'wdrl} <- pmatch pscriptContext'txInfo
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProtocolParams.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProtocolParams.hs
index 4b8aa5a8..4f2752c4 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProtocolParams.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Contracts/ProtocolParams.hs
@@ -21,7 +21,7 @@ import SmartTokens.Types.Constants (pprotocolParamsTokenData)
 
 -- | Protocol Parameters minting policy
 -- This validator allows minting of a single token with a single token name.
-mkProtocolParametersMinting :: ClosedTerm (PAsData PTxOutRef :--> PScriptContext :--> PUnit)
+mkProtocolParametersMinting :: Term s (PAsData PTxOutRef :--> PScriptContext :--> PUnit)
 mkProtocolParametersMinting = plam $ \oref ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'inputs, ptxInfo'mint} <- pmatch pscriptContext'txInfo
@@ -43,7 +43,7 @@ mkProtocolParametersMinting = plam $ \oref ctx -> P.do
 -- | Permissioned Minting Policy
 -- This minting policy checks for a given permissioned credential in the signatories of the transaction.
 -- It allows minting of any number of tokens with any token name so long as the credential authorizes the transaction.
-mkPermissionedMinting :: ClosedTerm (PData :--> PAsData PPubKeyHash :--> PScriptContext :--> PUnit)
+mkPermissionedMinting :: Term s (PData :--> PAsData PPubKeyHash :--> PScriptContext :--> PUnit)
 mkPermissionedMinting = plam $ \_ permissionedCred ctx ->
   pvalidateConditions
     [ ptxSignedByPkh # permissionedCred # (pfromData . ptxInfoSignatories . pscriptContextTxInfo) ctx
@@ -52,5 +52,5 @@ mkPermissionedMinting = plam $ \_ permissionedCred ctx ->
 -- | A nonced always fails script
 -- The parameter is used to modify the script hash.
 -- This is where the protocol parameters UTxO should reside.
-alwaysFailScript :: ClosedTerm (PData :--> PScriptContext :--> PUnit)
+alwaysFailScript :: Term s (PData :--> PScriptContext :--> PUnit)
 alwaysFailScript = plam $ \_ _ctx -> perror
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Core/Scripts.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Core/Scripts.hs
index 567143e8..2d5f0ef0 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Core/Scripts.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Core/Scripts.hs
@@ -11,8 +11,8 @@ module SmartTokens.Core.Scripts (
 
 import Data.Aeson (FromJSON, ToJSON)
 import GHC.Generics (Generic)
-import Plutarch.Internal.Term (ClosedTerm, Config (..), LogLevel (LogInfo),
-                               Script, TracingMode (..), compile)
+import Plutarch.Internal.Term (Config (..), LogLevel (LogInfo), Script, Term,
+                               TracingMode (..), compile)
 
 {-| Script target environment
 -}
@@ -29,15 +29,15 @@ targetConfig = \case
   Debug      -> _tracingConfig
   Production -> prodConfig
 
-tryCompile :: ScriptTarget -> ClosedTerm a -> Script
+tryCompile :: ScriptTarget -> (forall s. Term s a) -> Script
 tryCompile tgt x = case compile (targetConfig tgt) x of
   Left e -> error $ "Compilation failed: " <> show e
   Right s -> s
 
-tryCompileTracingAndBinds :: ClosedTerm a -> Script
+tryCompileTracingAndBinds :: (forall s. Term s a) -> Script
 tryCompileTracingAndBinds = tryCompile Debug
 
-tryCompileNoTracing :: ClosedTerm a -> Script
+tryCompileNoTracing :: (forall s. Term s a) -> Script
 tryCompileNoTracing = tryCompile Production
 
 _tracingAndBindsConfig :: Config
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/BlacklistCommon.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/BlacklistCommon.hs
index aaaa1d83..b7f6c500 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/BlacklistCommon.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/BlacklistCommon.hs
@@ -16,6 +16,7 @@ module SmartTokens.LinkedList.BlacklistCommon (
   nodeInputUtxoDatumUnsafePair,
 ) where
 
+import Data.Kind (Type)
 import GHC.Generics (Generic)
 import Plutarch.Core.Context
 import Plutarch.Core.List
@@ -40,7 +41,7 @@ ppaysToAddress = phoistAcyclic $ plam $ \adr txOut -> adr #== ptxOutAddress (pfr
      tokenName and amount
 -}
 correctNodeTokenMinted ::
-  ClosedTerm
+  forall s. Term s
     ( PCurrencySymbol
         :--> PTokenName
         :--> PInteger
@@ -56,7 +57,7 @@ correctNodeTokenMinted = phoistAcyclic $
 -- Potentially use this in the future if we plan to manage additional
 -- value in the directory nodes.
 nodeInputUtxoDatumUnsafePair ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PTxOut
         :--> PPair (PValue 'Sorted 'Positive) (PAsData PBlacklistNode)
     )
@@ -69,12 +70,12 @@ nodeInputUtxoDatumUnsafePair = phoistAcyclic $ plam $ \out ->
       _ -> ptraceInfoError "Expected output datum"
 
 nodeInputUtxoDatumUnsafe
-  :: ClosedTerm (PAsData PTxOut :--> PAsData PBlacklistNode)
+  :: Term s (PAsData PTxOut :--> PAsData PBlacklistNode)
 nodeInputUtxoDatumUnsafe = phoistAcyclic $ plam $ \txOut ->
   punsafeCoerce (ptxOutInlineDatumRaw $ pfromData txOut)
 
 parseNodeOutputUtxo ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PCurrencySymbol
         :--> PAsData PTxOut
         :--> PAsData PBlacklistNode
@@ -102,7 +103,7 @@ parseNodeOutputUtxo = phoistAcyclic $
     datum
 
 makeCommon ::
-  forall {r :: PType} {s :: S}.
+  forall {r :: S -> Type} {s :: S}.
   Term s PScriptContext ->
   TermCont @r
     s
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/Common.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/Common.hs
index 7eb31530..2c91d298 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/Common.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/Common.hs
@@ -15,6 +15,7 @@ module SmartTokens.LinkedList.Common (
   nodeInputUtxoDatumUnsafePair,
 ) where
 
+import Data.Kind (Type)
 import GHC.Generics (Generic)
 import Plutarch.Builtin.ByteString (pintegerToByteString, pmostSignificantFirst)
 import Plutarch.Builtin.Crypto (pblake2b_224)
@@ -41,7 +42,7 @@ ppaysToAddress = phoistAcyclic $ plam $ \adr txOut -> adr #== ptxOutAddress (pfr
      tokenName and amount
 -}
 correctNodeTokenMinted ::
-  ClosedTerm
+  forall s. Term s
     ( PCurrencySymbol
         :--> PTokenName
         :--> PInteger
@@ -57,7 +58,7 @@ correctNodeTokenMinted = phoistAcyclic $
 -- Potentially use this in the future if we plan to manage additional
 -- value in the directory nodes.
 nodeInputUtxoDatumUnsafePair ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PTxOut
         :--> PPair (PValue 'Sorted 'Positive) (PAsData PDirectorySetNode)
     )
@@ -70,12 +71,12 @@ nodeInputUtxoDatumUnsafePair = phoistAcyclic $ plam $ \out ->
       _ -> ptraceInfoError "Expected output datum"
 
 nodeInputUtxoDatumUnsafe
-  :: ClosedTerm (PAsData PTxOut :--> PAsData PDirectorySetNode)
+  :: Term s (PAsData PTxOut :--> PAsData PDirectorySetNode)
 nodeInputUtxoDatumUnsafe = phoistAcyclic $ plam $ \txOut ->
   punsafeCoerce (ptxOutInlineDatumRaw $ pfromData txOut)
 
 parseNodeOutputUtxo ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PCurrencySymbol
         :--> PAsData PTxOut
         :--> PAsData PDirectorySetNode
@@ -103,7 +104,7 @@ parseNodeOutputUtxo = phoistAcyclic $
     datum
 
 makeCommon ::
-  forall {r :: PType} {s :: S}.
+  forall {r :: S -> Type} {s :: S}.
   Term s PScriptContext ->
   TermCont @r
     s
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintBlacklist.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintBlacklist.hs
index 303daf00..a3b8e13a 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintBlacklist.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintBlacklist.hs
@@ -62,7 +62,7 @@ deriving via DeriveDataPLiftable PBlacklistNodeAction BlacklistNodeAction
   instance PLiftable PBlacklistNodeAction
 
 mkBlacklistNodeMP ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PTxOutRef
       :--> PAsData PPubKeyHash
       :--> PScriptContext
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintDirectory.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintDirectory.hs
index 296e351e..cae1c2f0 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintDirectory.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/MintDirectory.hs
@@ -58,7 +58,7 @@ deriving via DeriveDataPLiftable PDirectoryNodeAction DirectoryNodeAction
   instance PLiftable PDirectoryNodeAction
 
 mkDirectoryNodeMP ::
-  ClosedTerm
+  forall s. Term s
     ( PAsData PTxOutRef
       :--> PAsData PCurrencySymbol
       :--> PScriptContext
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendBlacklist.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendBlacklist.hs
index 72533084..49b08c7e 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendBlacklist.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendBlacklist.hs
@@ -16,14 +16,14 @@ import Plutarch.LedgerApi.V3 (PCurrencySymbol,
                               PScriptContext (PScriptContext, pscriptContext'scriptInfo, pscriptContext'txInfo),
                               PScriptInfo, PTxInfo (PTxInfo, ptxInfo'mint))
 import Plutarch.Monadic qualified as P
-import Plutarch.Prelude (ClosedTerm, PAsData, PBool, PEq ((#==)), PUnit, Term,
-                         pasConstr, pdata, pforgetData, pfromData, pfstBuiltin,
-                         plam, pmatch, ptraceInfoIfFalse, type (:-->), (#))
+import Plutarch.Prelude (PAsData, PBool, PEq ((#==)), PUnit, Term, pasConstr,
+                         pdata, pforgetData, pfromData, pfstBuiltin, plam,
+                         pmatch, ptraceInfoIfFalse, type (:-->), (#))
 
 pisSpendingPurpose :: Term s (PAsData PScriptInfo) -> Term s PBool
 pisSpendingPurpose term = (pfstBuiltin # (pasConstr # pforgetData term)) #== 1
 
-pmkBlacklistSpending :: ClosedTerm (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
+pmkBlacklistSpending :: Term s (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
 pmkBlacklistSpending = plam $ \blacklistMP ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'mint} <- pmatch pscriptContext'txInfo
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendDirectory.hs b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendDirectory.hs
index f1a8e31f..78d7add9 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendDirectory.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/LinkedList/SpendDirectory.hs
@@ -21,7 +21,7 @@ import Plutarch.Prelude
 import Plutarch.Unsafe (punsafeCoerce)
 import SmartTokens.Types.ProtocolParams
 
-pmkDirectoryGlobalLogic :: ClosedTerm (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
+pmkDirectoryGlobalLogic :: Term s (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
 pmkDirectoryGlobalLogic = plam $ \protocolParamsCS ctx -> P.do
   PScriptContext {pscriptContext'txInfo, pscriptContext'scriptInfo} <- pmatch ctx
   PTxInfo {ptxInfo'referenceInputs, ptxInfo'mint} <- pmatch pscriptContext'txInfo
@@ -40,7 +40,7 @@ pmkDirectoryGlobalLogic = plam $ \protocolParamsCS ctx -> P.do
       pvalidateConditions [phasDataCS # pdirectoryNodeCS # pfromData ptxInfo'mint]
     _ -> perror
 
-pmkDirectorySpendingYielding :: ClosedTerm (PAsData PCredential :--> PScriptContext :--> PUnit)
+pmkDirectorySpendingYielding :: Term s (PAsData PCredential :--> PScriptContext :--> PUnit)
 pmkDirectorySpendingYielding = plam $ \globalCred ctx -> P.do
   PScriptContext {pscriptContext'txInfo} <- pmatch ctx
   PTxInfo {ptxInfo'wdrl} <- pmatch pscriptContext'txInfo
@@ -50,7 +50,7 @@ pmkDirectorySpendingYielding = plam $ \globalCred ctx -> P.do
     PJust _ -> (pconstant ())
     PNothing -> perror
 
-pmkDirectorySpending :: ClosedTerm (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
+pmkDirectorySpending :: Term s (PAsData PCurrencySymbol :--> PScriptContext :--> PUnit)
 pmkDirectorySpending = plam $ \protocolParamsCS ctx -> P.do
   PScriptContext {pscriptContext'txInfo} <- pmatch ctx
   PTxInfo {ptxInfo'referenceInputs, ptxInfo'mint} <- pmatch pscriptContext'txInfo
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Types/Constants.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Types/Constants.hs
index d78f98c3..6edf0ff5 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Types/Constants.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Types/Constants.hs
@@ -17,34 +17,34 @@ module SmartTokens.Types.Constants(
 ) where
 
 import Plutarch.LedgerApi.V1 (PTokenName (..))
-import Plutarch.Prelude (ClosedTerm, PAsData, pconstant)
+import Plutarch.Prelude (PAsData, Term, pconstant)
 import PlutusLedgerApi.V1 (TokenName (..))
 import PlutusTx.Builtins.HasOpaque (stringToBuiltinByteString)
 
 protocolParamsToken :: TokenName
 protocolParamsToken = TokenName (stringToBuiltinByteString "ProtocolParams")
 
-pprotocolParamsToken :: ClosedTerm PTokenName
+pprotocolParamsToken :: Term s PTokenName
 pprotocolParamsToken = pconstant protocolParamsToken
 
-pprotocolParamsTokenData :: ClosedTerm (PAsData PTokenName)
+pprotocolParamsTokenData :: Term s (PAsData PTokenName)
 pprotocolParamsTokenData = pconstant protocolParamsToken
 
 directoryNodeToken :: TokenName
 directoryNodeToken = TokenName ""
 
-pdirectoryNodeToken :: ClosedTerm PTokenName
+pdirectoryNodeToken :: Term s PTokenName
 pdirectoryNodeToken = pconstant directoryNodeToken
 
-pdirectoryNodeTokenData :: ClosedTerm (PAsData PTokenName)
+pdirectoryNodeTokenData :: Term s (PAsData PTokenName)
 pdirectoryNodeTokenData = pconstant directoryNodeToken
 
 issuanceCborHexToken :: TokenName
 issuanceCborHexToken = TokenName (stringToBuiltinByteString "IssuanceCborHex")
 
-pissuanceCborHexToken :: ClosedTerm PTokenName
+pissuanceCborHexToken :: Term s PTokenName
 pissuanceCborHexToken = pconstant issuanceCborHexToken
 
-pissuanceCborHexTokenData :: ClosedTerm (PAsData PTokenName)
+pissuanceCborHexTokenData :: Term s (PAsData PTokenName)
 pissuanceCborHexTokenData = pconstant issuanceCborHexToken
 
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Types/PTokenDirectory.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Types/PTokenDirectory.hs
index 2abbcda2..5e4e00c7 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Types/PTokenDirectory.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Types/PTokenDirectory.hs
@@ -53,7 +53,7 @@ import PlutusTx.Prelude qualified as PlutusTx
 -- >>> import Plutarch.Internal.Other (printScript)
 -- >>> import qualified Data.Text as T
 -- >>> import qualified Plutarch.Internal as PI
--- >>> let printTerm :: HasCallStack => Config -> ClosedTerm a -> String ; printTerm config term = printScript $ either (error . T.unpack) id $ PI.compile config term
+-- >>> let printTerm :: HasCallStack => Config -> (forall s. Term s a) -> String ; printTerm config term = printScript $ either (error . T.unpack) id $ PI.compile config term
 --
 -- Setup for doctest / HLS. Everything in this block is available for each test. Function
 -- definitions are a bit annoying but we probably should introduce printTerm somewhere anyway and
@@ -109,27 +109,27 @@ deriving via DeriveDataPLiftable (PAsData PBlacklistNode) BlacklistNode
 -- >>> printTerm NoTracing (pconstant $ BlacklistNode { blnKey = "a hi", blnNext = "a" })
 -- "program 1.0.0 (List [B #61206869, B #61])"
 
-pmkBlacklistNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode)
+pmkBlacklistNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode)
 pmkBlacklistNode = phoistAcyclic $
   plam $ \key_ next_ ->
     punsafeCoerce $ plistData # pmkBuiltinList [pforgetData key_, pforgetData next_]
 
-pisInsertedOnBlacklistNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode :--> PBool)
+pisInsertedOnBlacklistNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode :--> PBool)
 pisInsertedOnBlacklistNode = phoistAcyclic $
   plam $ \insertedKey coveringKey outputNode ->
     let expectedDirectoryNode = pmkBlacklistNode # coveringKey # insertedKey
      in outputNode #== expectedDirectoryNode
 
-pisInsertedBlacklistNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode :--> PBool)
+pisInsertedBlacklistNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PBlacklistNode :--> PBool)
 pisInsertedBlacklistNode = phoistAcyclic $
   plam $ \insertedKey coveringNext outputNode ->
     let expectedDirectoryNode = pmkBlacklistNode # insertedKey # coveringNext
     in outputNode #== expectedDirectoryNode
 
-pemptyBlacklistNode :: ClosedTerm (PAsData PBlacklistNode)
+pemptyBlacklistNode :: Term s (PAsData PBlacklistNode)
 pemptyBlacklistNode = punsafeCoerce $ plistData # pmkBuiltinList [pforgetData pemptyBSData, pforgetData ptailBlackListNext]
 
-ptailBlackListNext  :: ClosedTerm (PAsData PByteString)
+ptailBlackListNext  :: Term s (PAsData PByteString)
 ptailBlackListNext = unsafeEvalTerm NoTracing (punsafeCoerce $ pdata (phexByteStr "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
 
 pisBlacklistTailNode :: Term s (PAsData PBlacklistNode) -> Term s PBool
@@ -203,7 +203,7 @@ isTailNode node =
 >>> _printTerm $ unsafeEvalTerm NoTracing emptyNode
 "program\n  1.0.0\n  (List\n     [ B #\n     , B #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\n     , Constr 0 [B #]\n     , Constr 0 [B #] ])"
 -}
-emptyNode :: ClosedTerm (PAsData PDirectorySetNode)
+emptyNode :: Term s (PAsData PDirectorySetNode)
 emptyNode =
   let nullTransferLogicCred = pconstant (Constr 0 [PlutusTx.B ""])
       nullIssuerLogicCred = pconstant (Constr 0 [PlutusTx.B ""])
@@ -213,27 +213,27 @@ pisEmptyNode :: Term s (PAsData PDirectorySetNode) -> Term s PBool
 pisEmptyNode node =
   node #== emptyNode
 
-pemptyBSData :: ClosedTerm (PAsData PByteString)
+pemptyBSData :: Term s (PAsData PByteString)
 pemptyBSData = unsafeEvalTerm NoTracing (punsafeCoerce (pconstant @PData $ PlutusTx.B ""))
 
-pemptyCSData :: ClosedTerm (PAsData PCurrencySymbol)
+pemptyCSData :: Term s (PAsData PCurrencySymbol)
 pemptyCSData = unsafeEvalTerm NoTracing (punsafeCoerce (pconstant @PData $ PlutusTx.B ""))
 
-ptailNextData  :: ClosedTerm (PAsData PCurrencySymbol)
+ptailNextData  :: Term s (PAsData PCurrencySymbol)
 ptailNextData = unsafeEvalTerm NoTracing (punsafeCoerce $ pdata (phexByteStr "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"))
 
-pmkDirectorySetNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PCredential :--> PAsData PCredential :--> PAsData PCurrencySymbol :--> PAsData PDirectorySetNode)
+pmkDirectorySetNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PCredential :--> PAsData PCredential :--> PAsData PCurrencySymbol :--> PAsData PDirectorySetNode)
 pmkDirectorySetNode = phoistAcyclic $
   plam $ \key_ next_ transferLogicCred issuerLogicCred globalStateCS_ ->
     punsafeCoerce $ plistData # pmkBuiltinList [pforgetData key_, pforgetData next_, pforgetData transferLogicCred, pforgetData issuerLogicCred, pforgetData globalStateCS_]
 
-pisInsertedOnNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PCredential :--> PAsData PCredential :--> PAsData PCurrencySymbol :--> PAsData PDirectorySetNode :--> PBool)
+pisInsertedOnNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PCredential :--> PAsData PCredential :--> PAsData PCurrencySymbol :--> PAsData PDirectorySetNode :--> PBool)
 pisInsertedOnNode = phoistAcyclic $
   plam $ \insertedKey coveringKey transferLogicCred issuerLogicCred globalCS outputNode ->
     let expectedDirectoryNode = pmkDirectorySetNode # coveringKey # insertedKey # transferLogicCred # issuerLogicCred # globalCS
      in outputNode #== expectedDirectoryNode
 
-pisInsertedNode :: ClosedTerm (PAsData PByteString :--> PAsData PByteString :--> PAsData PDirectorySetNode :--> PBool)
+pisInsertedNode :: Term s (PAsData PByteString :--> PAsData PByteString :--> PAsData PDirectorySetNode :--> PBool)
 pisInsertedNode = phoistAcyclic $
   plam $ \insertedKey coveringNext outputNode ->
     pmatch (pfromData outputNode) $ \(PDirectorySetNode {ptransferLogicScript, pissuerLogicScript, pglobalStateCS}) ->
diff --git a/src/programmable-tokens-onchain/lib/SmartTokens/Types/ProtocolParams.hs b/src/programmable-tokens-onchain/lib/SmartTokens/Types/ProtocolParams.hs
index 1a7bf84d..b4f1e8a4 100644
--- a/src/programmable-tokens-onchain/lib/SmartTokens/Types/ProtocolParams.hs
+++ b/src/programmable-tokens-onchain/lib/SmartTokens/Types/ProtocolParams.hs
@@ -17,7 +17,7 @@ module SmartTokens.Types.ProtocolParams (
   PProgrammableLogicGlobalParams (..),
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api.Plutus qualified as C
 import Control.Lens ((&), (.~), (?~))
 import Data.Aeson (FromJSON (..), ToJSON (..), object, withObject, (.:), (.=))
 import Data.Aeson qualified as Aeson
diff --git a/src/programmable-tokens-onchain/lib/Types/Constants.hs b/src/programmable-tokens-onchain/lib/Types/Constants.hs
index cfd56a47..b98b0871 100644
--- a/src/programmable-tokens-onchain/lib/Types/Constants.hs
+++ b/src/programmable-tokens-onchain/lib/Types/Constants.hs
@@ -15,7 +15,7 @@ import PlutusLedgerApi.V1 (TokenName (..))
 pnodeKeyTN :: Term s PByteString -> Term s PTokenName
 pnodeKeyTN nodeKey = pcon $ PTokenName $ nodeKey
 
-poriginNodeTN :: ClosedTerm PTokenName
+poriginNodeTN :: Term s PTokenName
 poriginNodeTN =
   let tn :: TokenName
       tn = TokenName ""
diff --git a/src/programmable-tokens-test/lib/ProgrammableTokens/Test.hs b/src/programmable-tokens-test/lib/ProgrammableTokens/Test.hs
index dc0691bb..1a49d28f 100644
--- a/src/programmable-tokens-test/lib/ProgrammableTokens/Test.hs
+++ b/src/programmable-tokens-test/lib/ProgrammableTokens/Test.hs
@@ -21,7 +21,7 @@ module ProgrammableTokens.Test(
 ) where
 
 import Cardano.Api (Quantity)
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Cardano.Ledger.Api qualified as Ledger
 import Cardano.Ledger.Plutus.ExUnits (ExUnits (..))
 import Control.Lens ((%~), (&))
diff --git a/src/programmable-tokens-test/test/ProgrammableTokens/Test/DirectorySet.hs b/src/programmable-tokens-test/test/ProgrammableTokens/Test/DirectorySet.hs
index 6910616e..284b392c 100644
--- a/src/programmable-tokens-test/test/ProgrammableTokens/Test/DirectorySet.hs
+++ b/src/programmable-tokens-test/test/ProgrammableTokens/Test/DirectorySet.hs
@@ -3,7 +3,7 @@ module ProgrammableTokens.Test.DirectorySet(
   tests
 ) where
 
-import Cardano.Api.Shelley qualified as C
+import Cardano.Api qualified as C
 import Control.Monad.Except (MonadError)
 import Convex.BuildTx qualified as BuildTx
 import Convex.Class (MonadMockchain, MonadUtxoQuery, sendTx)
@@ -48,7 +48,7 @@ issueAlwaysSucceedsValidator scriptRoot = do
   runAs' registerAlwaysSucceedsStakingCert
 
   runAs' $ do
-    Test.issueProgrammableTokenTx "dummy asset" 100 ()
+    Test.issueProgrammableTokenTx (C.UnsafeAssetName "dummy asset") 100 ()
       >>= void . sendTx . signTxOperator Test.admin
     Query.registryNodes @C.ConwayEra
       >>= void . Test.expectN 2 "registry outputs"