Avoid double jamming terms from bytes and base64 prove arguments

app/Commands/Dev/Anoma/Base.hs

@@ -32,26 +32,31 @@ runNock ::
   AppPath File ->
   [ProveArg] ->
   Sem r Anoma.RunNockmaResult
-runNock programFile pargs = do
-  argsfile <- fromAppPathFile programFile
-  parsedTerm <- runAppError @JuvixError (Nockma.cueJammedFileOrPretty argsfile)
-  args <- mapM proveArgToTerm pargs
+runNock programAppPath pargs = do
+  programFile <- fromAppPathFile programAppPath
+  parsedProgram <- runAppError @JuvixError (Nockma.cueJammedFileOrPretty programFile)
+  args <- mapM prepareArg pargs
   Anoma.runNockma
     Anoma.RunNockmaInput
-      { _runNockmaProgram = parsedTerm,
+      { _runNockmaProgram = parsedProgram,
         _runNockmaArgs = args
       }
 
-proveArgToTerm :: forall r. (Members '[Error SimpleError, Files, App] r) => ProveArg -> Sem r (Term Natural)
-proveArgToTerm = \case
-  ProveArgNat n -> return (toNock n)
-  ProveArgBytes n -> fromAppPathFile n >>= readFileBS' >>= fromBytes
+prepareArg :: forall r. (Members '[Error SimpleError, Files, App] r) => ProveArg -> Sem r Anoma.RunNockmaArg
+prepareArg = \case
+  ProveArgNat n -> return (Anoma.RunNockmaArgTerm (toNock n))
+  ProveArgBytes n -> do
+    bs <- readAppFile n
+    Anoma.RunNockmaArgJammed <$> fromBytes bs
   ProveArgBase64 n -> do
-    bs <- Base64.decodeLenient <$> (fromAppPathFile n >>= readFileBS')
-    fromBytes bs
+    bs <- readAppFile n
+    Anoma.RunNockmaArgJammed <$> fromBytes (Base64.decodeLenient bs)
   where
-    fromBytes :: ByteString -> Sem r (Term Natural)
-    fromBytes b = TermAtom <$> asSimpleErrorShow @NockNaturalNaturalError (byteStringToAtom @Natural b)
+    fromBytes :: ByteString -> Sem r (Atom Natural)
+    fromBytes b = asSimpleErrorShow @NockNaturalNaturalError (byteStringToAtom @Natural b)
+
+    readAppFile :: AppPath File -> Sem r ByteString
+    readAppFile f = fromAppPathFile f >>= readFileBS'
 
 -- | Calls Anoma.Protobuf.Mempool.AddTransaction
 addTransaction ::

app/Commands/Dev/Anoma/Prove/Options/ProveArgTag.hs

@@ -34,8 +34,8 @@ proveArgTagHelp = itemize (tagHelp <$> allElements)
       let mvar, explain :: AnsiDoc
           (mvar, explain) = first sty $ case t of
             ProveArgTagNat -> ("NATURAL", "is passed verbatim as a nockma atom")
-            ProveArgTagBase64 -> ("FILE", "is a file with a base64 encoded nockma atom")
-            ProveArgTagBytes -> ("FILE", "is a file with a byte encoded nockma atom")
+            ProveArgTagBase64 -> ("FILE", "is a file containing a base64 encoded nockma atom that represents a jammed noun")
+            ProveArgTagBytes -> ("FILE", "is a file containing bytes of a nockma atom that represents a jammed noun")
           sty = annotate (bold <> colorDull Blue)
           tagvar :: AnsiDoc
           tagvar = sty (show t <> ":" <> mvar)

src/Anoma/Effect/RunNockma.hs

@@ -13,9 +13,16 @@ import Juvix.Prelude
 import Juvix.Prelude.Aeson (Value)
 import Juvix.Prelude.Aeson qualified as Aeson
 
+-- | An argument to a program sent to the RunNock endpoint
+data RunNockmaArg
+  = -- | An argument that must be jammed before it is sent
+    RunNockmaArgTerm (Nockma.Term Natural)
+  | -- | An argument that is already jammed and must not be jammed again before it is sent
+    RunNockmaArgJammed (Nockma.Atom Natural)
+
 data RunNockmaInput = RunNockmaInput
   { _runNockmaProgram :: Nockma.Term Natural,
-    _runNockmaArgs :: [Nockma.Term Natural]
+    _runNockmaArgs :: [RunNockmaArg]
   }
 
 data RunNockmaResult = RunNockmaResult
@@ -33,7 +40,7 @@ runNockma ::
   Sem r RunNockmaResult
 runNockma i = do
   let prog' = encodeJam64 (i ^. runNockmaProgram)
-      args = map (NockInputJammed . encodeJam64) (i ^. runNockmaArgs)
+      args = map prepareArgument (i ^. runNockmaArgs)
       msg =
         RunNock
           { _runNockJammedProgram = prog',
@@ -54,3 +61,9 @@ runNockma i = do
             _runNockmaTraces = traces
           }
     ResponseError err -> throw (SimpleError (mkAnsiText (err ^. errorError)))
+  where
+    prepareArgument :: RunNockmaArg -> NockInput
+    prepareArgument =
+      NockInputJammed . \case
+        RunNockmaArgTerm t -> encodeJam64 t
+        RunNockmaArgJammed a -> naturalToBase64 (a ^. Nockma.atom)

src/Juvix/Compiler/Nockma/Encoding/ByteString.hs

@@ -5,6 +5,7 @@ import Data.Bit (Bit)
 import Data.Bit qualified as Bit
 import Data.Bits
 import Data.ByteString qualified as BS
+import Data.ByteString.Base64 qualified as Base64
 import Data.ByteString.Builder qualified as BS
 import Juvix.Compiler.Nockma.Encoding.Base
 import Juvix.Compiler.Nockma.Encoding.Effect.BitReader
@@ -32,6 +33,9 @@ byteStringToNatural = fromInteger . byteStringToIntegerLE
 naturalToByteString :: Natural -> ByteString
 naturalToByteString = naturalToByteStringLE
 
+naturalToBase64 :: Natural -> Text
+naturalToBase64 = decodeUtf8 . Base64.encode . naturalToByteString
+
 byteStringToIntegerLE :: ByteString -> Integer
 byteStringToIntegerLE = BS.foldr (\b acc -> acc `shiftL` 8 .|. fromIntegral b) 0
 

test/Anoma/Client/Positive.hs

@@ -46,7 +46,7 @@ proveAndSubmit program proveArgs = do
     runNockma
       RunNockmaInput
         { _runNockmaProgram = program,
-          _runNockmaArgs = proveArgs
+          _runNockmaArgs = map RunNockmaArgTerm proveArgs
         }
   step "Submitting transaction candidate"
   addTransaction

test/Anoma/Compilation/Positive.hs

@@ -102,7 +102,7 @@ mkAnomaNodeTest a@AnomaTest {..} =
           let rinput =
                 RunNockmaInput
                   { _runNockmaProgram = program,
-                    _runNockmaArgs = _anomaArgs
+                    _runNockmaArgs = map RunNockmaArgTerm _anomaArgs
                   }
           out <- runNockma rinput
           runM