Optimal non-builtin valueOf in plutus-ledger-api Data.Value

Rewrites `PlutusLedgerApi.V1.Data.Value.valueOf` so the non-builtin lookup
path walks the underlying `BuiltinList` directly via `unsafeDataAsMap` /
`unsafeDataAsB` / `unsafeDataAsI`, compares keys with `equalsByteString`,
and short-circuits on the first match. No `Maybe` is materialised: the
"absent" answer is `0`, returned in-place by the `nilCase` of each
traversal. Avoids `withCurrencySymbol`'s continuation + `Map.lookup`'s
`Maybe`-wrapping, and bypasses the `ToData k`/`UnsafeFromData a` dictionary
work that `AssocMap.lookup` does per element. Semantics preserved.

Adds `Spec.Data.Value.test_valueOf`: a QuickCheck property that compiles
`valueOf` via TH, evaluates it on the CEK machine, and compares the result
against the host-Haskell `valueOf` for the same inputs. Differential test
against the Plinth compiler — any divergence is a compilation bug, not a
semantics bug.

Budget evidence (lookup matrix, `unsafeDataAsValue` baseline) lives on the
companion experimental branch `yura/issue-2242-valueof-evidence`, kept out
of this PR to avoid carrying ~96 golden files that would only ever regenerate
on upstream plugin/cost-model changes.

For IntersectMBO/plutus-private#2242.

Author: Unisay

plutus-ledger-api/changelog.d/20260527_123507_yuriy.lazaryev_issue_2242_optimal_valueof.md

@@ -0,0 +1,3 @@
+### Changed
+
+- `PlutusLedgerApi.V1.Data.Value.valueOf` rewritten to walk the underlying `BuiltinList` directly via `unsafeDataAsMap` / `unsafeDataAsB` / `unsafeDataAsI` and short-circuit on the first match. The previous implementation went through `Map.lookup`, which materialised a `Maybe` only to deconstruct it immediately, and paid `ToData k` / `UnsafeFromData a` dictionary work per element. Semantics are unchanged.

plutus-ledger-api/src/PlutusLedgerApi/V1/Data/Value.hs

@@ -336,11 +336,18 @@ instance MeetSemiLattice Value where
 {-| Get the quantity of the given currency in the 'Value'.
 Assumes that the underlying map doesn't contain duplicate keys. -}
 valueOf :: Value -> CurrencySymbol -> TokenName -> Integer
-valueOf value cur tn =
-  withCurrencySymbol cur value 0 \tokens ->
-    case Map.lookup tn tokens of
-      Nothing -> 0
-      Just v -> v
+valueOf (Value mp) (CurrencySymbol curBs) (TokenName tnBs) =
+  goOuter (Map.toBuiltinList mp)
+  where
+    goOuter = B.caseList' 0 \hd ->
+      if B.equalsByteString curBs (BI.unsafeDataAsB (BI.fst hd))
+        then \_ -> goInner (BI.unsafeDataAsMap (BI.snd hd))
+        else goOuter
+
+    goInner = B.caseList' 0 \hd ->
+      if B.equalsByteString tnBs (BI.unsafeDataAsB (BI.fst hd))
+        then \_ -> BI.unsafeDataAsI (BI.snd hd)
+        else goInner
 {-# INLINEABLE valueOf #-}
 
 {-| Apply a continuation function to the token quantities of the given currency

plutus-tx-plugin/test-ledger-api/Spec.hs

@@ -27,6 +27,7 @@ tests =
     , Spec.Data.Budget.tests
     , Spec.Data.ScriptContext.tests
     , Spec.Data.Value.test_EqValue
+    , Spec.Data.Value.test_valueOf
     , Spec.Data.MintValue.V3.tests
     , Spec.Envelope.tests
     , Spec.ReturnUnit.V1.tests

plutus-tx-plugin/test-ledger-api/Spec/Data/Value.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE BlockArguments #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE TemplateHaskell #-}
@@ -13,8 +14,11 @@ import Prelude qualified as Haskell
 import PlutusLedgerApi.V1.Data.Value
 
 import PlutusTx.Base
+import PlutusTx.Builtins qualified as B
+import PlutusTx.Builtins.Internal qualified as BI
 import PlutusTx.Code (CompiledCode, getPlc, unsafeApplyCode)
 import PlutusTx.Data.AssocMap qualified as AssocMap
+import PlutusTx.IsData qualified as Tx
 import PlutusTx.Lift
 import PlutusTx.List qualified as List
 import PlutusTx.Maybe
@@ -31,12 +35,16 @@ import UntypedPlutusCore qualified as PLC
 import UntypedPlutusCore.Evaluation.Machine.Cek qualified as PLC
 
 import Control.Exception qualified as Haskell
+import Data.ByteString qualified as BS
 import Data.Functor qualified as Haskell
 import Data.List qualified as Haskell
 import Data.Map qualified as Map
+import PlutusLedgerApi.Test.V1.Data.Value qualified as ListToValue
 import Prettyprinter qualified as Pretty
+import Test.QuickCheck (Arbitrary (arbitrary), forAll, (===))
 import Test.Tasty
 import Test.Tasty.Extras
+import Test.Tasty.QuickCheck (testProperty)
 
 scalingFactor :: Integer
 scalingFactor = 4
@@ -258,3 +266,74 @@ test_EqValue =
     $ [ test_EqCurrencyList "Short" currencyListOptions
       , test_EqCurrencyList "Long" currencyLongListOptions
       ]
+
+-- | Compiled non-builtin 'valueOf', evaluated on CEK by the property test.
+compiledValueOf :: CompiledCode (Value -> CurrencySymbol -> TokenName -> Integer)
+compiledValueOf = $$(compile [||valueOf||])
+
+{-| Compiled builtin lookup: @\\bd cs tn -> lookupCoin cs tn (unsafeDataAsValue bd)@.
+Used as the independent oracle in the differential property test for 'valueOf'. -}
+compiledBuiltinLookup
+  :: CompiledCode (BI.BuiltinData -> BI.BuiltinByteString -> BI.BuiltinByteString -> Integer)
+compiledBuiltinLookup =
+  $$(compile [||\bd c t -> B.lookupCoin c t (B.unsafeDataAsValue bd)||])
+
+-- | Run a compiled program that produces an 'Integer' on the CEK machine.
+runIntegerOnCek :: CompiledCode Integer -> Integer
+runIntegerOnCek prog =
+  let (errOrRes, _) =
+        PLC.runCekNoEmit PLC.defaultCekParametersForTesting PLC.counting
+          . PLC.runQuote
+          . PLC.unDeBruijnTermWith (Haskell.error "Free variable")
+          . PLC._progTerm
+          $ getPlc prog
+   in either Haskell.throw id $ errOrRes >>= PLC.readKnownSelf
+
+{-| Check that the non-builtin 'valueOf' agrees with the builtin lookup path
+('unsafeDataAsValue' + 'lookupCoin') when both are evaluated on the CEK machine.
+The two paths share no source code, so any disagreement is a bug in one of them.
+
+The two paths differ in their entry points: the builtin path decodes
+'BuiltinData' through 'unsafeDataAsValue', which validates ledger-level
+well-formedness and fails on ill-formed input; the non-builtin path goes through
+'unsafeFromBuiltinData :: BuiltinData -> Value', which is essentially a 'coerce'
+through the newtype layers down to the underlying 'BuiltinList' and validates
+nothing. The lookup operations themselves ('lookupCoin', 'valueOf') validate
+nothing in either case. On-chain values come through the ledger pre-validated,
+so we compare the two paths on the same domain by normalising each generated
+value before the lookup (sort outer and inner maps, drop zero-quantity tokens,
+drop currencies with empty token maps). -}
+test_valueOf :: TestTree
+test_valueOf =
+  testProperty "non-builtin valueOf matches builtin lookupCoin on CEK" \rawValue ->
+    let value =
+          ListToValue.listsToValue
+            . Haskell.sortOn fst
+            . Haskell.filter (Haskell.not . Haskell.null . snd)
+            . Haskell.map
+              ( Haskell.fmap
+                  ( Haskell.sortOn fst
+                      . Haskell.filter ((Haskell./= 0) . snd)
+                  )
+              )
+            $ ListToValue.valueToLists rawValue
+        genBytes = Haskell.fmap BS.pack arbitrary
+        genKeyPair =
+          Haskell.liftA2
+            (\bs1 bs2 -> (currencySymbol bs1, tokenName bs2))
+            genBytes
+            genBytes
+     in forAll genKeyPair \(cs, tn) ->
+          let nonBuiltin =
+                runIntegerOnCek
+                  $ compiledValueOf
+                  `unsafeApplyCode` liftCodeDef value
+                  `unsafeApplyCode` liftCodeDef cs
+                  `unsafeApplyCode` liftCodeDef tn
+              builtin =
+                runIntegerOnCek
+                  $ compiledBuiltinLookup
+                  `unsafeApplyCode` liftCodeDef (Tx.toBuiltinData value)
+                  `unsafeApplyCode` liftCodeDef (unCurrencySymbol cs)
+                  `unsafeApplyCode` liftCodeDef (unTokenName tn)
+           in nonBuiltin === builtin