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 #-}
@@ -22,6 +23,7 @@ import PlutusTx.Numeric
 import PlutusTx.Prelude hiding (integerToByteString)
 import PlutusTx.Show (toDigits)
 import PlutusTx.TH (compile)
+import PlutusTx.Test.Run.Code (evaluationResultMatchesHaskell)
 import PlutusTx.Traversable qualified as Tx
 
 import PlutusCore.Builtin qualified as PLC
@@ -31,12 +33,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 ()
 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 +264,24 @@ test_EqValue =
     $ [ test_EqCurrencyList "Short" currencyListOptions
       , test_EqCurrencyList "Long" currencyLongListOptions
       ]
+
+{-| Check that running the compiled 'valueOf' on CEK produces the same
+'Integer' as the host-Haskell 'valueOf', for arbitrary 'Value's and
+arbitrary @(CurrencySymbol, TokenName)@ pairs. -}
+test_valueOf :: TestTree
+test_valueOf =
+  testProperty "valueOf on CEK matches host Haskell" \value ->
+    let genBytes = Haskell.fmap BS.pack arbitrary
+        genKeyPair =
+          Haskell.liftA2
+            (\bs1 bs2 -> (currencySymbol bs1, tokenName bs2))
+            genBytes
+            genBytes
+     in forAll genKeyPair \(cs, tn) ->
+          let compiled =
+                $$(compile [||valueOf||])
+                  `unsafeApplyCode` liftCodeDef value
+                  `unsafeApplyCode` liftCodeDef cs
+                  `unsafeApplyCode` liftCodeDef tn
+              expected = valueOf value cs tn
+           in evaluationResultMatchesHaskell compiled (===) expected