diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1f47fdd0..7d16253b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -114,10 +114,10 @@ jobs: run: sbt +update - name: Check formatting - run: sbt '++ ${{ matrix.scala }}' scalafmtCheckAll scalafmtSbtCheck benchmarks/scalafmtCheck + run: sbt '++ ${{ matrix.scala }}' scalafmtCheckAll scalafmtSbtCheck benchmarks/scalafmtCheck demoUplcJvm/scalafmtCheckAll demoUplcJvmValidators/scalafmtCheckAll demoUplcJvmBench/scalafmtCheckAll - name: Check scalafix - run: sbt '++ ${{ matrix.scala }}' 'scalafixAll --check' + run: sbt '++ ${{ matrix.scala }}' 'scalafixAll --check' 'demoUplcJvm/scalafixAll --check' 'demoUplcJvmValidators/scalafixAll --check' 'demoUplcJvmBench/scalafixAll --check' - name: Check that workflows are up to date run: sbt githubWorkflowCheck @@ -133,13 +133,16 @@ jobs: if: matrix.java == 'temurin@25' && matrix.os == 'ubuntu-22.04' run: sbt '++ ${{ matrix.scala }}' doc + - name: Test UPLC → JVM demo (differential vs Scalus CEK) + run: sbt '++ ${{ matrix.scala }}' demoUplcJvm/test demoUplcJvmBench/Jmh/compile + - name: Make target directories if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v')) - run: mkdir -p jsoniter/target benchmarks/target kyo/target target circe/target zio/target unidocs/target avro/target laws/target tests/target generics/target schemes-laws/target schemes/target core/target project/target + run: mkdir -p jsoniter/target benchmarks/target kyo/target target demos/uplc-jvm-bench/target circe/target zio/target unidocs/target avro/target laws/target tests/target generics/target demos/uplc-jvm-validators/target schemes-laws/target schemes/target core/target demos/uplc-jvm/target project/target - name: Compress target directories if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v')) - run: tar cf targets.tar jsoniter/target benchmarks/target kyo/target target circe/target zio/target unidocs/target avro/target laws/target tests/target generics/target schemes-laws/target schemes/target core/target project/target + run: tar cf targets.tar jsoniter/target benchmarks/target kyo/target target demos/uplc-jvm-bench/target circe/target zio/target unidocs/target avro/target laws/target tests/target generics/target demos/uplc-jvm-validators/target schemes-laws/target schemes/target core/target demos/uplc-jvm/target project/target - name: Upload target directories if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v')) diff --git a/CLAUDE.md b/CLAUDE.md index 6fc12eb3..6ad4de29 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -28,10 +28,19 @@ Test-only: `org.typelevel:discipline-specs2_3:2.0.0`. | `zio` | `zio/` | `cats-eo-zio` | ZIO 2 integration: `ZEnvironment` service lens, capability-driven `Ref` focus ops, `ZLayer` projection through `CanGet`; STM focus ops on `TRef`/`TMap` (USTM-returning — multi-focus updates compose into one transaction); `Chunks.each/at/eachNonEmpty` constructors (private Traverse adapters — the orphan given belongs to zio-interop-cats). Three `% Optional` sub-packages (callers add the artifact, avro/circe/kyo pattern): `eo.zio.schema` — `EoAccessorBuilder` fills zio-schema's own AccessorBuilder extension point (Lens per field / Prism per case / Traversal per collection, no macros), `DynamicValues` untyped-tree kit (constructor prisms + generic `primitive(st)`, `field`/`at`/`key`/`variant`/`each`, `Plated`), `schema.dynamicPrism` typed↔untyped, `BinaryCodec.prism` byte face (json/protobuf/avro/msgpack/thrift); `eo.zio.json` — circe playbook on `zio.json.ast.Json` (`JsonValues` prisms + navigation + `Plated` + `text` String↔Json face, `JsonCodec.stringPrism`) plus `JsonCursor.optional` bridging zio-json's own typed paths; `eo.zio.prelude` — `Validations.success` (Optional; prism would drop the log) + `eachFailure` (error-polymorphic traversal). Cross-format spec fuel: zio-schema-derivation + zio-schema-json are Test-scope | | `kyo` | `kyo/` | `cats-eo-kyo` | Kyo integration (kyo-prelude 1.0.0-RC6 — kyo RC5+ ships Java-25-only bytecode, so this module REQUIRES JDK 25 and leaves the root aggregate on older JVMs; CI's primary lane is 25): `TypeMap` service lens, `Env.focus` / `Layer.focus`, `Var` focus ops; `Record.iso[T]` (quoted macro, NamedTuple OR case class ↔ `Record`, no arity ceiling) + `Record.lens[F]("name")` field lenses via `Fields.Have`; `StructureValues.field`/`key` target the FIRST match (Chunk-backed ⇒ duplicates representable; write-all breaks `modify(identity)`), and `atField` is the At-shaped create/delete optic — lawful up to field ORDER only (delete destroys the position a later insert would restore, so put-put fails; `NavigationTests` yes, `SeamTests` no — the zio kits hide the same behaviour behind order-insensitive equality); the `eo.kyo.schema` sub-package bridges kyo-schema (`% Optional` — callers add it themselves, avro/circe pattern): `Focus` → Lens/Optional, `Schema.prism[Codec]` / `stringPrism` byte-face prisms, and `StructureValues` — optics over the untyped `Structure.Value` tree (constructor prisms, `field`/`at`/`key`/`each`/`variant` navigation, `Plated[Value]`, `Schema.valuePrism` typed↔untyped; `variant` accepts both the declared `VariantCase` spelling AND the single-field wrapper record RC6's encoder actually emits). Module opts out of `-Yexplicit-nulls` (kyo's inline kernel isn't nulls-clean) and `-Wconf`-silences kyo-schema-origin warnings | | `benchmarks` | `benchmarks/` | — (not published) | JMH benchmarks vs Monocle (not part of root aggregate) | +| `demoUplcJvm` | `demos/uplc-jvm/` | — (not published) | Demo: UPLC (Cardano Plutus Core) → JVM bytecode as a chain of LAWFUL monomorphic eo optics, `CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript` (stages `toTyped`, `lowering`, `compiling` — the last is `UplcJvm.compile` / `decompile`; callers use `UplcJvm.toTyped` / `toJvmClass` / `toBytecode`, all from the script, all `MendTearPrism`s). Two PRISMS around one iso: Scalus decodes ANY declared Plutus Core version, but the ledger takes only those Plutus V3 has at PV11 (`Semantics.versions` = 1.0.0, 1.1.0), so `toTyped` misses on any other; a class can exceed the JVM's 64 KB method / 65 535-constant limits, so `compiling` misses (`UplcJvm.compile` gives the limit as a `Left` — the one catch of ASM's `MethodTooLargeException` / `ClassTooLargeException`). `lowering`'s way back types the embedded script WITHOUT the version check (only a typed program is lowered). Lawful because every stage keeps its script — `TypedProgram` its source, the class the script as Base64 constants — so `reverseGet` walks back exactly; `OpticSpec` runs cats-eo-laws' `PrismTests` on `toTyped` and `toBytecode` (JvmClass has no equality, so no `IsoTests` for `lowering`); tests reach stages through `Oracle.typed` / `jvmClass` / `classFile`, and `Oracle.compare` checks the round trips on every program. The four types hand out COPIES only (`bytes`, `tree`), so nothing changes a value after the compiler made or checked it. Compile time is STACK SAFE (`OpticSpec` compiles 100 000-deep programs on a 1 MB stack): decode, `Typer` and `Lower` are walks of `Step`s (`Step.scala`) — plain calls while shallow, `cats.Eval` on the heap from `Walk.Deep` (128) calls deep — so EVERY recursive call must go through `Walk.nested`. Trampolining every node (plain `Eval`) made translation ~2× slower. Steps run once each, in order, so `Lower` writes instructions as a step is made. Never sequence effectful `Eval`s with cats' `traverse_` / `void`: cats treats `Eval` as pure and drops a step whose result is unused. Scalus' flat decoder/encoder still recurse (overflow at 2 000–20 000 deep on 1 MB). `CborScript` / `JvmClassScript` are opaque over Scalus' `ByteString` (value equality, so the laws can use `==`), `JvmClass` opaque over ASM's `ClassNode` (made only by `Lower` and `UplcJvm.decompile`; `.tree` to inspect); `CborScript.parse` is the checked entry for untrusted bytes. Compiled with `-opt -opt-inline:**,!scala.**`: inlining from the Scala library made the short validations 12–27% slower (it grows `Rt.force` past what the JIT inlines), everything else measured neutral to ~5% faster. Keep generated code free of unreachable instructions (the typer drops what follows a failure): dead code leaves constant-pool entries that break the class file's read/write fixpoint. TypedProgram = typed Scala-like expression over Scalus' own `Term`s (hybrid typing: types are Scalus `DefaultUni`s, builtin signatures its `TypeScheme`s, instantiated at argument types; unboxed `BigInt`/`boolean`/`ByteString`/`String` where provable, boxed Scalus `Constant`s elsewhere), JvmClass written by asm-commons' `InstructionAdapter` (no own IR — and not a library above ASM: those cost translation speed), class file by ASM `ClassWriter` (computes frames). Saturated builtins are direct JVM calls of `scalus.uplc.builtin.Builtins` (or lazy-`Data` natives in `Rt`); the rest, and builtins used as values, run Scalus' CEK meanings. Reuse Scalus code before adding demo-local code: failures are `MachineError`, `Exec.run` returns `eval.Result`. Correctness is DIFFERENTIAL against the Scalus 1.3.0 CEK machine (Plutus V3 @ PV11, variant E — `Semantics.scala`): vendored Plutus conformance suite (`src/test/resources/plutus-conformance`, regenerate with `scripts/refresh-conformance.sh`, never hand-edit) + validators. Result/error only — no budget metering. Not in the root aggregate (Scalus pulls JNI crypto); CI runs `demoUplcJvm/test` as its own step. See its README | +| `demoUplcJvmValidators` | `demos/uplc-jvm-validators/` | — (not published) | On-chain validators compiled to UPLC by `scalus-plugin` (isolated so the plugin never sees the compiler's sources), plus the shared off-chain fixtures (`Contexts`, `Scenarios`); test-scope dep of `demoUplcJvm` | +| `demoUplcJvmBench` | `demos/uplc-jvm-bench/` | — (not published) | JMH for the demo: CEK machine vs generated class per validator, Fibonacci scaling, translation cost. NOT part of `benchmarks/`, the nightly sweep or `BENCHMARKS.md`; its numbers live on `site/docs/demos/uplc-jvm.md`. CI only compiles it (`demoUplcJvmBench/Jmh/compile`) | The root project aggregates `core`, `laws`, `tests`, `generics`, `schemes`, `schemesLaws`, `circe`, `avro`, `jsoniter`, `zio`, and `kyo`. `sbt compile` and `sbt test` -cover those; benchmarks must be invoked explicitly (see below). +cover those; benchmarks and the `demoUplcJvm` demo must be invoked explicitly +(see below; `sbt demoUplcJvm/test`). + +Published modules compile with Scala 3's bytecode optimizer (`scala3LibrarySettings` in +`build.sbt`): `-opt`, plus `-opt-inline:dev.constructive.eo.**` — the inliner may copy code +only from eo's own packages, never from cats, the JDK or the Scala library, whose next +releases would leave stale copies in our jars. ## Toolchain diff --git a/README.md b/README.md index 34d567cc..47c3309e 100644 --- a/README.md +++ b/README.md @@ -139,6 +139,9 @@ for cats typeclasses. - ZIO integration: - Kyo integration (Records, kyo-schema bridge): - Cookbook (recipes): +- Demo — a UPLC (Cardano Plutus Core) → JVM bytecode compiler built as one + eo `Iso`, checked against the Scalus CEK machine: + [`demos/uplc-jvm`](./demos/uplc-jvm/README.md) - Benchmarks vs Monocle: [`BENCHMARKS.md`](./BENCHMARKS.md) (generated each sweep; B/op is the comparable metric, ns/op is directional) - Composition gap analysis (research): diff --git a/build.sbt b/build.sbt index cbf57a80..8c982fdc 100644 --- a/build.sbt +++ b/build.sbt @@ -65,15 +65,31 @@ ThisBuild / githubWorkflowBuildPreamble ++= Seq( "scalafmtCheckAll", "scalafmtSbtCheck", "benchmarks/scalafmtCheck", + "demoUplcJvm/scalafmtCheckAll", + "demoUplcJvmValidators/scalafmtCheckAll", + "demoUplcJvmBench/scalafmtCheckAll", ), name = Some("Check formatting"), ), WorkflowStep.Sbt( - List("scalafixAll --check"), + List( + "scalafixAll --check", + "demoUplcJvm/scalafixAll --check", + "demoUplcJvmValidators/scalafixAll --check", + "demoUplcJvmBench/scalafixAll --check", + ), name = Some("Check scalafix"), ), ) +// The UPLC → JVM demo sits outside the root aggregate (Scalus drags in JNI +// crypto bindings, bouncycastle, borer, upickle, monocle), so `sbt test` and +// the pre-push hook stay lean; CI runs its differential suite as its own step. +ThisBuild / githubWorkflowBuild += WorkflowStep.Sbt( + List("demoUplcJvm/test", "demoUplcJvmBench/Jmh/compile"), + name = Some("Test UPLC → JVM demo (differential vs Scalus CEK)"), +) + // ------------------------------------------------------------------- // Scalafix wiring. SemanticDB exports are required by the semantic // rules (RemoveUnused, OrganizeImports). Rule set lives in @@ -520,10 +536,11 @@ lazy val commonSettings = Seq( // method (box elim, null-check folding, dead-code elim, copy // propagation) and touches neither TASTy nor call boundaries, so // downstream binary-compat checks see nothing. `-opt-inline` DOES cross -// method/class boundaries and is reserved for [[scala3CoreSettings]] -// only, with the `` scope so nothing from cats / JDK is baked -// into our jar (a future cats release can't be invalidated by stale -// inline copies). Laws / generics / circe stay on `-opt` only. +// method/class boundaries, so it is scoped to this library's own +// packages, `dev.constructive.eo.**`: nothing from cats / the JDK / the +// Scala library is baked into our jars (a future cats release can't be +// invalidated by stale inline copies), while one eo module may inline +// another's code, as all of them are released together. // // `-Yretain-trees` keeps full ASTs in published TASTy so downstream // callers' `inline def` expansions can see through our bodies. @@ -539,6 +556,7 @@ lazy val commonSettings = Seq( lazy val scala3LibrarySettings = Seq( scalacOptions ++= Seq( "-opt", // method-local JVM bytecode optimizer + "-opt-inline:dev.constructive.eo.**", // inline across methods, from eo's own code only "-Yretain-trees", // downstream `inline def` / macros see our bodies "-Wsafe-init", // catch `val` init-order bugs in companion objects "-Yexplicit-nulls", // non-nullable reference types by default @@ -552,19 +570,6 @@ lazy val scala3LibrarySettings = Seq( ) ) -// Pure library modules with no dependency on another artifact's -// internals can additionally enable `-opt-inline:` — inlines -// only between files compiled together in the current sub-project, -// leaving external libraries untouched so their future bug-fixes keep -// flowing through. Applied to `core/` only; `circeIntegration/` -// deliberately omits it (crosses into circe, where we must NOT bake -// internals). `generics/` also omits it — inlining across macro -// expansions is both unnecessary and risks leaking compiler-internals -// into user bytecode. -lazy val scala3CoreSettings = scala3LibrarySettings ++ Seq( - scalacOptions += "-opt-inline:" -) - // Macro-bearing modules additionally enable `-Xcheck-macros` so // malformed quotes surface at macro-compile time rather than as NPEs // in downstream builds. @@ -597,7 +602,7 @@ lazy val root: Project = project lazy val core: Project = project .in(file("core")) .settings(commonSettings *) - .settings(scala3CoreSettings *) + .settings(scala3LibrarySettings *) .settings( name := "cats-eo", libraryDependencies += cats, @@ -1150,6 +1155,76 @@ lazy val benchmarks: Project = project libraryDependencies += jsoniterMacros, ) +// ------------------------------------------------------------------- +// Demo: a UPLC (Cardano Plutus Core) → JVM bytecode compiler built from eo isos, +// CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript — the script in, a class +// file out, and the class hands its script back. Correctness +// is differential: every program runs through the generated class AND the +// Scalus CEK machine, and the two results must agree. Unpublished and OUT of +// the root aggregate (see the CI step above); run with `sbt demoUplcJvm/test`. +// ------------------------------------------------------------------- +lazy val ScalusVersion = "1.3.0" +lazy val scalus = "org.scalus" %% "scalus" % ScalusVersion +// JvmClass is ASM's own in-memory class (asm-tree); asm-commons' InstructionAdapter writes it. +lazy val AsmVersion = "9.11" +lazy val asmCommons = "org.ow2.asm" % "asm-commons" % AsmVersion +lazy val asmUtil = "org.ow2.asm" % "asm-util" % AsmVersion + +lazy val demoUplcJvm: Project = project + .in(file("demos/uplc-jvm")) + .dependsOn( + LocalProject("core"), + // IsoTests: the suite checks the optics' round-trip laws with the library's own rule set. + LocalProject("laws") % Test, + LocalProject("demoUplcJvmValidators") % Test, + ) + .settings(commonSettings *) + .settings( + name := "cats-eo-demo-uplc-jvm", + publish / skip := true, + libraryDependencies += scalus, + libraryDependencies += asmCommons, + // Textifier: the walkthrough prints a JvmClass as bytecode. + libraryDependencies += asmUtil % Test, + libraryDependencies += discipline % Test, + // Unpublished, so the optimizer may inline from anything on the classpath (Scalus, ASM, + // cats, eo) — except Scala's own library: inlining it into the runtime makes `Rt.force` too + // big for the JIT to inline, and the short validations ran 12-27% slower (measured with the + // demo's JMH benches; everything else inlined measures neutral to ~5% faster). + scalacOptions ++= Seq("-opt", "-opt-inline:**,!scala.**"), + ) + +// On-chain validators written in Scala and compiled to UPLC by the Scalus +// compiler plugin — the second half of the demo's oracle corpus. Isolated in +// its own module so the plugin (and the Scalus-flavoured Scala it accepts) +// never touches the compiler's own sources. +lazy val demoUplcJvmValidators: Project = project + .in(file("demos/uplc-jvm-validators")) + .settings(commonSettings *) + .settings( + name := "cats-eo-demo-uplc-jvm-validators", + publish / skip := true, + libraryDependencies += scalus, + addCompilerPlugin("org.scalus" % "scalus-plugin" % ScalusVersion cross CrossVersion.full), + ) + +// JMH benchmarks for the demo: the CEK machine against the generated class, and what the +// translation itself costs. Kept apart from `benchmarks/` so the nightly sweep and +// BENCHMARKS.md stay about the library; results are reported on the demo's docs page. +// Run with `sbt "demoUplcJvmBench/Jmh/run -prof gc"`. +lazy val demoUplcJvmBench: Project = project + .in(file("demos/uplc-jvm-bench")) + .enablePlugins(JmhPlugin) + .dependsOn( + LocalProject("demoUplcJvm"), + LocalProject("demoUplcJvmValidators"), + ) + .settings(commonSettings *) + .settings( + name := "cats-eo-demo-uplc-jvm-bench", + publish / skip := true, + ) + // Single source of truth for the JMH invocation (the config that the per-class // annotations pin — see JmhDefaults' Phase-4 note for why that preamble can't be // DRY'd). Append a filter: `sbt "bench .*OrderAvroBench.*"`. diff --git a/demos/uplc-jvm-bench/src/main/scala/dev/constructive/eo/demo/uplc/bench/ValidatorBench.scala b/demos/uplc-jvm-bench/src/main/scala/dev/constructive/eo/demo/uplc/bench/ValidatorBench.scala new file mode 100644 index 00000000..bb7b6493 --- /dev/null +++ b/demos/uplc-jvm-bench/src/main/scala/dev/constructive/eo/demo/uplc/bench/ValidatorBench.scala @@ -0,0 +1,103 @@ +package dev.constructive.eo.demo.uplc +package bench + +import scala.compiletime.uninitialized + +import dev.constructive.eo.demo.uplc.runtime.{Dispatch, Rt} +import dev.constructive.eo.demo.uplc.validators.{Scenario, Scenarios} +import java.util.concurrent.TimeUnit +import org.openjdk.jmh.annotations.* +import scalus.uplc.eval.{NoBudgetSpender, NoLogger} +import scalus.uplc.{Constant, DeBruijnedProgram, Program, Term} + +/** A validator's script: it has a flat encoding, or the setup fails. */ +def script(program: Program): CborScript = CborScript.of(program).fold(sys.error, identity) + +/** Its class file: it has one, or the setup fails. */ +def classFile(script: CborScript): JvmClassScript = + UplcJvm.toBytecode.getOption(script).getOrElse(sys.error("no class file")) + +/** Shared state: one accepting transaction, ready for both evaluators. + * + * - `cek` — Scalus' CEK machine evaluating the script applied to its context, the way the ledger + * runs it, minus budget accounting (the generated code meters nothing either). + * - `jvm` — the generated class, translated and loaded once in setup: evaluate the script, apply + * it to the context. + */ +abstract class ScriptState: + + protected def scenario: Scenario + + var applied: DeBruijnedProgram = uninitialized + var compiled: Dispatch = uninitialized + var context: Constant = uninitialized + + @Setup(Level.Trial) + def prepare(): Unit = + val s = scenario + applied = (s.script.program $ s.context).deBruijnedProgram + val classFile = bench.classFile(script(s.script.program)) + compiled = Exec.load(classFile) + context = Constant.Data(s.context) + // Both evaluators must accept the transaction, or the timings compare different work. + val accepted = + cek == Term.Const(Constant.Unit) && Exec.validate(classFile, s.context).isRight + require(accepted, s"${s.name}: an evaluator rejects the benchmark transaction") + + @Benchmark def cek: Term = Semantics.vm.evaluateScript(applied, NoBudgetSpender, NoLogger) + + @Benchmark def jvm: AnyRef = Rt.apply(compiled.run(), context) + +/** Each validator validating one accepting transaction. */ +@State(Scope.Benchmark) +@BenchmarkMode(Array(Mode.AverageTime)) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Fork(value = 3, jvmArgsAppend = Array("-Xss256m")) +@Warmup(iterations = 3, time = 1) +@Measurement(iterations = 5, time = 1) +class ValidatorBench extends ScriptState: + + @Param(Array("helloOwner", "preimage", "timeLock", "multisig", "fibonacci", "htlc")) + var validator: String = uninitialized + + protected def scenario: Scenario = Scenarios.accepting.find(_.name == validator).get + +/** The Fibonacci puzzle at growing `n`: how each evaluator scales with interpretive work. Slow + * operations reach steady state late — with 3 × 1 s of warm-up the first measured iteration of + * every fork was still being compiled — hence the longer warm-up. + */ +@State(Scope.Benchmark) +@BenchmarkMode(Array(Mode.AverageTime)) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Fork(value = 3, jvmArgsAppend = Array("-Xss256m")) +@Warmup(iterations = 5, time = 2) +@Measurement(iterations = 5, time = 1) +class FibonacciBench extends ScriptState: + + @Param(Array("10", "100", "1000")) + var n: Int = uninitialized + + protected def scenario: Scenario = Scenarios.fibonacciAt(n) + +/** What the translation costs: flat bytes to class file, and to a loaded, initialised class. */ +@State(Scope.Benchmark) +@BenchmarkMode(Array(Mode.AverageTime)) +@OutputTimeUnit(TimeUnit.MICROSECONDS) +@Fork(value = 3, jvmArgsAppend = Array("-Xss256m")) +@Warmup(iterations = 3, time = 1) +@Measurement(iterations = 5, time = 1) +class TranslateBench: + + @Param(Array("helloOwner", "preimage", "timeLock", "multisig", "fibonacci", "htlc")) + var validator: String = uninitialized + + var script: CborScript = uninitialized + + @Setup(Level.Trial) + def prepare(): Unit = + script = bench.script(Scenarios.accepting.find(_.name == validator).get.script.program) + + @Benchmark def translate: Option[JvmClassScript] = UplcJvm.toBytecode.getOption(script) + + @Benchmark def translateAndLoad: Option[Dispatch] = + UplcJvm.toBytecode.getOption(script).map(Exec.load) diff --git a/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Scenarios.scala b/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Scenarios.scala new file mode 100644 index 00000000..1ce43733 --- /dev/null +++ b/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Scenarios.scala @@ -0,0 +1,104 @@ +package dev.constructive.eo.demo.uplc.validators + +import scalus.cardano.onchain.plutus.prelude.{List as PList, Option as POption} +import scalus.cardano.onchain.plutus.v1.Value +import scalus.cardano.onchain.plutus.v2.TxOut +import scalus.cardano.onchain.plutus.v3.* +import scalus.uplc.PlutusV3 +import scalus.uplc.builtin.Data.toData +import scalus.uplc.builtin.{Builtins, ByteString, Data} + +// Off-chain fixtures shared by the demo's specs, its walkthrough and its benchmarks: the parties, +// a V3 spending-context builder, and one transaction each validator accepts. + +/** Key and script hashes are 28 bytes, transaction ids 32. */ +object Parties: + def hash(size: Int, byte: Int): ByteString = ByteString.fill(size, byte.toByte) + val alice: PubKeyHash = PubKeyHash(hash(28, 0xa1)) + val bob: PubKeyHash = PubKeyHash(hash(28, 0xb0)) + val carol: PubKeyHash = PubKeyHash(hash(28, 0xca)) + +object Contexts: + + val ownRef: TxOutRef = TxOutRef(TxId(Parties.hash(32, 0x01)), 0) + + /** The script context of a transaction spending one script-locked output. */ + def spending( + datum: Data, + redeemer: Data, + signatories: Seq[PubKeyHash] = Nil, + validRange: Interval = Interval.always, + ): Data = + val ownInput = TxInInfo( + ownRef, + TxOut( + Address(Credential.ScriptCredential(Parties.hash(28, 0x5c)), POption.None), + Value.lovelace(10_000_000), + ), + ) + ScriptContext( + txInfo = TxInfo( + inputs = PList(ownInput), + fee = 188021, + validRange = validRange, + signatories = PList.from(signatories), + id = TxId(Parties.hash(32, 0xfe)), + ), + redeemer = redeemer, + scriptInfo = ScriptInfo.SpendingScript(ownRef, POption.Some(datum)), + ).toData + +/** A validator, the script context of a transaction, and whether the validator must accept it. */ +final case class Scenario(name: String, script: PlutusV3[?], context: Data, accepts: Boolean = true) + +object Scenarios: + import CompiledValidators.* + import Contexts.spending as tx + import Parties.* + + def fib(n: Int): BigInt = + (1 to n).foldLeft((BigInt(0), BigInt(1)))((p, _) => (p._2, p._1 + p._2))._1 + + /** The Fibonacci puzzle solved for `n`: `n` levels of integer recursion. */ + def fibonacciAt(n: Int): Scenario = + Scenario(s"fibonacci($n)", fibonacci, tx(fib(n).toData, BigInt(n).toData)) + + private def bytes(s: String) = ByteString.fromString(s) + private val (owner, hello, unit) = (alice.toData, "Hello, World!".toData, Data.unit) + private val (secret, htlcSecret) = (bytes("open sesame"), bytes("htlc secret")) + private val image = (Builtins.sha2_256(secret), bob.hash).toData + private val (deadline, timeout) = (1_700_000_000_000L, 1_800_000_000_000L) + private val (lock, locked) = (Lock(carol, deadline).toData, Interval.after(deadline - 1)) + private val quorum = Quorum(PList(alice, bob, carol), 2).toData + private val contract = Contract(alice, bob, Builtins.sha2_256(htlcSecret), timeout).toData + private val (claim, refund) = (HtlcAction.Claim(htlcSecret).toData, HtlcAction.Refund.toData) + private val guess = HtlcAction.Claim(bytes("guess")).toData + private val (inTime, late) = (Interval.before(timeout - 1), Interval.before(timeout + 1)) + private val (after, early) = (Interval.after(timeout + 1), Interval.after(timeout - 1)) + + /** Transactions the validators must accept or reject. */ + lazy val all: List[Scenario] = List( + Scenario("helloOwner", helloOwner, tx(owner, hello, List(alice))), + Scenario("helloOwner: not signed", helloOwner, tx(owner, hello, List(bob)), false), + Scenario("helloOwner: wrong greeting", helloOwner, tx(owner, "Hi".toData, List(alice)), false), + Scenario("preimage", preimage, tx(image, secret.toData, List(bob))), + Scenario("preimage: wrong", preimage, tx(image, bytes("barley").toData, List(bob)), false), + Scenario("preimage: not signed", preimage, tx(image, secret.toData, List(alice)), false), + Scenario("timeLock", timeLock, tx(lock, unit, List(carol), Interval.after(deadline))), + Scenario("timeLock: too early", timeLock, tx(lock, unit, List(carol), locked), false), + Scenario("timeLock: no lower bound", timeLock, tx(lock, unit, List(carol)), false), + Scenario("multisig", multisig, tx(quorum, unit, List(alice, carol))), + Scenario("multisig: three signers", multisig, tx(quorum, unit, List(carol, bob, alice))), + Scenario("multisig: one signer", multisig, tx(quorum, unit, List(bob)), false), + fibonacciAt(30).copy(name = "fibonacci"), + fibonacciAt(400), // an 84-digit answer, 400 frames deep + Scenario("fibonacci: wrong", fibonacci, tx((fib(30) + 1).toData, BigInt(30).toData), false), + Scenario("htlc", htlc, tx(contract, claim, List(bob), inTime)), + Scenario("htlc: claim too late", htlc, tx(contract, claim, List(bob), late), false), + Scenario("htlc: wrong preimage", htlc, tx(contract, guess, List(bob), inTime), false), + Scenario("htlc: refund", htlc, tx(contract, refund, List(alice), after)), + Scenario("htlc: refund too early", htlc, tx(contract, refund, List(alice), early), false), + ) + + /** One accepting transaction per validator: what the walkthrough and the benchmarks run. */ + lazy val accepting: List[Scenario] = all.filter(_.accepts).distinctBy(_.script) diff --git a/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Validators.scala b/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Validators.scala new file mode 100644 index 00000000..e42c2fca --- /dev/null +++ b/demos/uplc-jvm-validators/src/main/scala/dev/constructive/eo/demo/uplc/validators/Validators.scala @@ -0,0 +1,110 @@ +package dev.constructive.eo.demo.uplc.validators + +import scalus.cardano.onchain.plutus.prelude.* +import scalus.cardano.onchain.plutus.v3.* +import scalus.compiler.{Compile, Options} +import scalus.uplc.PlutusV3 +import scalus.uplc.builtin.Builtins.sha2_256 +import scalus.uplc.builtin.Data.{FromData, ToData} +import scalus.uplc.builtin.{ByteString, Data} + +// On-chain code for the UPLC → JVM demo's oracle corpus. Every object below is +// compiled to UPLC by the Scalus compiler plugin; the demo's suite then runs each +// script, applied to hand-built V3 script contexts, through BOTH the Scalus CEK +// machine and the JVM class the demo emits, and demands the two agree. +// +// The validators deliberately cover different shapes of generated UPLC: Data +// decoding and list search (HelloOwner, Preimage), a crypto builtin (Preimage), +// interval inspection (TimeLock), folds with integer arithmetic (Multisig), +// tight self-recursion (Fibonacci), and enum pattern matching (Htlc). + +/** Spending requires the owner's signature and the redeemer `"Hello, World!"`. */ +@Compile +object HelloOwner extends Validator: + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val owner = datum.getOrFail("Datum not found").to[PubKeyHash] + require(tx.signatories.contains(owner), "Must be signed") + require(redeemer.to[String] == "Hello, World!", "Invalid redeemer") + +/** Datum `(sha2_256(preimage), pkh)`: the redeemer must be the preimage, signed by `pkh`. */ +@Compile +object Preimage extends Validator: + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val (hash, pkh) = datum.getOrFail("Expected datum").to[(ByteString, ByteString)] + val preimage = redeemer.toByteString + tx.signatories.find(_.hash == pkh).orFail("Not signed") + require(sha2_256(preimage) == hash, "Wrong preimage") + +case class Lock(beneficiary: PubKeyHash, deadline: PosixTime) derives FromData, ToData + +/** Funds unlock for the beneficiary once the validity range starts at or after the deadline. */ +@Compile +object TimeLock extends Validator: + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val lock = datum.getOrFail("No datum").to[Lock] + require(tx.isSignedBy(lock.beneficiary), "Not signed by beneficiary") + require(tx.validFromOrFail("No lower bound") >= lock.deadline, "Too early") + +case class Quorum(signers: List[PubKeyHash], required: BigInt) derives FromData, ToData + +/** m-of-n multisig: counts how many listed signers signed the transaction. */ +@Compile +object Multisig extends Validator: + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val quorum = datum.getOrFail("No datum").to[Quorum] + val signed = + quorum.signers.foldLeft(BigInt(0))((n, key) => if tx.isSignedBy(key) then n + 1 else n) + require(signed >= quorum.required, "Not enough signatures") + +/** A puzzle lock: the redeemer `n` must satisfy `fib(n) == datum`. Pure integer recursion. */ +@Compile +object Fibonacci extends Validator: + + def fib(n: BigInt, a: BigInt, b: BigInt): BigInt = + if n <= 0 then a else fib(n - 1, b, a + b) + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val n = redeemer.to[BigInt] + val expected = datum.getOrFail("No datum").to[BigInt] + require(fib(n, 0, 1) == expected, "Wrong answer") + +case class Contract(owner: PubKeyHash, receiver: PubKeyHash, hash: ByteString, timeout: PosixTime) + derives FromData, + ToData + +enum HtlcAction derives FromData, ToData: + case Claim(preimage: ByteString) + case Refund + +/** Hash-time-locked contract: the receiver claims with the preimage before the timeout, the owner + * refunds after it. + */ +@Compile +object Htlc extends Validator: + + override inline def spend(datum: Option[Data], redeemer: Data, tx: TxInfo, ref: TxOutRef): Unit = + val contract = datum.getOrFail("No datum").to[Contract] + redeemer.to[HtlcAction] match + case HtlcAction.Claim(preimage) => + require(tx.isSignedBy(contract.receiver), "Not signed by receiver") + require(tx.validToOrFail("No upper bound") <= contract.timeout, "Too late") + require(sha2_256(preimage) == contract.hash, "Wrong preimage") + case HtlcAction.Refund => + require(tx.isSignedBy(contract.owner), "Not signed by owner") + require(tx.validFromOrFail("No lower bound") > contract.timeout, "Too early") + +/** The compiled scripts, ready to be applied to a script context. */ +object CompiledValidators: + + private given Options = Options.release + + lazy val helloOwner = PlutusV3.compile(HelloOwner.validate) + lazy val preimage = PlutusV3.compile(Preimage.validate) + lazy val timeLock = PlutusV3.compile(TimeLock.validate) + lazy val multisig = PlutusV3.compile(Multisig.validate) + lazy val fibonacci = PlutusV3.compile(Fibonacci.validate) + lazy val htlc = PlutusV3.compile(Htlc.validate) diff --git a/demos/uplc-jvm/README.md b/demos/uplc-jvm/README.md new file mode 100644 index 00000000..bee81258 --- /dev/null +++ b/demos/uplc-jvm/README.md @@ -0,0 +1,211 @@ +# UPLC → JVM bytecode, as eo optics + +A compiler from Untyped Plutus Core (UPLC, the language Cardano smart contracts +run in) to JVM class files, built from cats-eo optics. Correctness is +established differentially: every program runs through the generated class AND +through the [Scalus](https://scalus.org) CEK machine, and the two must agree. + +```scala +import dev.constructive.eo.demo.uplc.* + +val script = CborScript.of(program) // or CborScript.parse(bytes): Either[String, CborScript] + +UplcJvm.toTyped // CborScript ⇀ TypedProgram: the program as a typed, Scala-like expression +UplcJvm.toJvmClass // CborScript ⇀ JvmClass: its JVM class, in memory (ASM's class tree) +UplcJvm.toBytecode // CborScript ⇀ JvmClassScript: its class file + +UplcJvm.toBytecode.getOption(script) match // the compiler + case Some(classFile) => + UplcJvm.toBytecode.reverseGet(classFile) // == script: the class carries its script + Exec.validate(classFile, scriptContext) // Right(traces) | Left(reason), CIP-117 + case None => // a Plutus Core version the compiler does not know, or a class too large for a file +``` + +The three optics a caller wants all start at the script as the ledger stores it, +and each is a chain of the compiler's stages — all three prisms: + +``` +CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript + toTyped lowering compiling +``` + +| type | what it is | +|---|---| +| `CborScript` | a script as the ledger stores it: the flat-encoded program in a CBOR bytestring (opaque, over Scalus' `ByteString`) | +| `TypedProgram` | the program read back as a typed, Scala-like expression tree | +| `JvmClass` | the script's JVM class in memory — [ASM](https://asm.ow2.io)'s `ClassNode`, inspectable before it is a file (opaque; only the compiler and `UplcJvm.decompile` make one) | +| `JvmClassScript` | a class file the compiler wrote (opaque, over Scalus' `ByteString`) | + +Every stage keeps the script it came from: a typed program its source, a class +the script itself, embedded in its constants. So each arrow can be walked back. +`lowering` is a lawful iso on what the compiler produces — there and back is the +identity, both ways. The other two are prisms, total on the way back: + +- `toTyped`: a script can declare any Plutus Core version, and Scalus decodes + them all; the ledger only takes the ones Plutus V3 has at protocol version 11, + 1.0.0 and 1.1.0 (`Semantics.versions`). A script of another version has no + typed program. +- `compiling`: the JVM caps a method at 64 KB of bytecode and a class at 65 535 + constants, so a class can be too large for a class file, and then there is + none (`UplcJvm.compile` says which limit, as a `Left`). + +So the compiler, `toBytecode`, is a prism too. The suite checks the prism laws +with cats-eo's own `PrismTests`, and the round trips on every program it +compiles. None of the four types hands out what it holds — `bytes` +and `tree` are copies — so a value cannot change after the compiler made or +checked it, and the way back always works. The other property that matters is +the commuting square: *running `toBytecode.getOption(s)` gives what the CEK +machine gives for `s`*. + +## Pipeline + +``` +CborScript ──decode──▶ SourceProgram ──Typer──▶ TypedProgram ──Lower──▶ JvmClass ──ClassWriter──▶ JvmClassScript + (Scalus Terms, pre-order (re-sugaring, (closure conversion, (stack map + ids shared with runtime) hybrid typing) boxing, direct calls) frames) +``` + +- **`SourceProgram`** is Scalus' own decoded `Term` tree with every node + numbered in pre-order. That numbering is the contract between compile time and + run time: a closure carries only its node id; the class embeds the script + and re-decodes it, so a result can be *discharged* back to a UPLC term + exactly as the CEK machine does. +- **`Typer`** (`toTyped.getOption`) recognises what UPLC compilers emit for constructs UPLC + lacks, using rewrites that are exact under CEK evaluation order: `let` + (immediately applied lambda chains), `if` (forced `ifThenElse` over delayed + branches, and the other selector builtins), saturated builtin calls, direct + calls of `let`-bound functions and of `let`-bound forced builtins, the + `case (constr k args…) [… f …]` multi-argument call, `force (delay t)`, and + recursion tied by self-application (`let f = λself … in … [f f] …`, which + Scalus emits for recursive functions) — its calls become direct calls too. +- **Hybrid typing.** A static type is a Scalus `DefaultUni`, and builtin + signatures are Scalus' own `TypeScheme`s: a polymorphic builtin's result type + is the scheme instantiated at its arguments' types, so `fstPair (unConstrData + d)` is an `integer` and a `case` on it is a JVM switch. Integers, booleans, + bytestrings and strings get unboxed representations (`BigInt`, `boolean`, + `ByteString`, `String`) wherever the typer can prove them — constants, typed + builtin results, `let`s of those, agreeing branches. Everything else — + functions, constructors, `Data`, values that flow through lambda parameters — + is a boxed Scalus `Constant` or a runtime closure. Boxing happens only where + the two meet. +- **`Lower`** (`lowering.get`) writes bytecode straight into ASM's tree with + asm-commons' `InstructionAdapter`. It converts closures (each captures exactly + its free variables, in the order `SourceProgram.captures` fixes for both + sides), inserts box/unbox, calls builtins directly, and moves a `let` body into + its own method once a method nears the JVM's 64 KB limit. The class holds a + static method per lambda chain / `delay`, a switch per call arity for closure + dispatch, and the script as Base64 string constants — what + `lowering.reverseGet` reads back. +- **`compiling`** is ASM's `ClassWriter` (`UplcJvm.compile`, which computes the + stack map frames, or says the class is too large) one way and `ClassReader` + (`UplcJvm.decompile`) the other. A class file survives being read and written + again byte for byte, because the generated code has no unreachable + instructions: an expression that can only fail is never followed by code. +- **Stack safety.** Compiling cannot overflow the JVM stack, however deep the + program. Decoding, typing and lowering are walks of `Step`s (`Step.scala`): + plain calls while a walk is shallow; from 128 calls deep, the rest runs on + the heap, from `cats.Eval`'s loop. A program nested 100 000 deep compiles on + a thread's default 1 MB stack, and a shallow one pays next to nothing for + it. +- **Runtime** (`runtime/`): closures, partial builtins, constructors, `case` + dispatch (including PV11 casing on builtin values), discharge. A saturated + builtin is a plain JVM call of the function Scalus' own `CardanoBuiltins` + wraps (`scalus.uplc.builtin.Builtins`), on unboxed values where its signature + allows. The list and pair builtins are runtime natives that read `Data` lazily: + `unConstrData` / `unListData` do not convert a whole field list to constants, + only the elements read. Every other builtin — and any builtin used as a value + — runs Scalus' CEK meaning (`BuiltinRuntime`). Failures are Scalus' + `MachineError`, and `Exec.run` returns Scalus' evaluation `Result` — the types + the CEK machine reports with. + +## Correctness + +The semantics are pinned in `Semantics.scala`: Plutus V3 at protocol version 11 +("van Rossem"), builtin semantics variant E — the configuration Scalus 1.3.0 +runs the Plutus conformance suite under. The oracle and the generated code's +runtime both read it from there. + +`sbt demoUplcJvm/test` runs the suites below. Every program any of them runs is +also checked for the round trips: its script comes back out of its class +(`toBytecode.reverseGet`), and its class file survives ASM reading and writing it +again (`compiling`). + +- **`ConformanceSpec`** — the Plutus conformance suite (plutus `1.63.0.0`, + vendored under `src/test/resources/plutus-conformance`, see its `SOURCE.md`). + All 943 evaluation cases agree with the CEK machine; 55 parser tests and one + program that is a bare free variable (no flat encoding exists for it) are + skipped. The suite's `.expected` files additionally pin each case's + success/failure, so the comparison cannot pass vacuously. +- **`ValidatorSpec`** — validators written in Scala and compiled to UPLC by the + Scalus plugin (`demos/uplc-jvm-validators`: owner + greeting, hash preimage, + time lock, 2-of-3 multisig, Fibonacci puzzle, HTLC), each with accepting and + rejecting V3 script contexts. Every script is checked twice: compiled once + and applied to the context at run time, and compiled with the context + applied. +- **`CompilerSpec`** — one hand-written program per compilation path, error + paths included, plus a 20 000-deep `let` chain. +- **`OpticSpec`** — the prism laws of `toTyped` and `toBytecode`, with + cats-eo-laws' `PrismTests` (a script of an unknown version and a program too + large for a class file among the scripts); that scripts, classes and class + files hand out copies; programs nested 100 000 deep compiled on a 1 MB stack; + and evidence that hybrid typing fires on real validator code. + +The JVM's bytecode verifier checks every generated class when `Exec.load` +defines it. + +## Scope + +- **No optimisation.** The compiler translates UPLC, it does not optimise it: + no constant folding, inlining, dead-code elimination, common-subexpression + elimination, specialisation or tail-call elimination. Every operation the + program performs still happens at run time, in the CEK machine's order; the + typer's rewrites read encodings back, they don't change the program. The + speed-ups come from running as JVM bytecode under the JIT, with values + unboxed and calls made directly where the types allow. The demo's own Scala + code is built with Scala 3's bytecode optimizer (`-opt -opt-inline:**,!scala.**`; + inlining from the Scala library measured slower — see `build.sbt`). +- Results and failures are compared; **execution budgets are not metered**. + Out-of-budget rejections, which the ledger applies, are a natural next step. +- Methods are split at `let` boundaries only — the shape compilers produce — + not inside one huge expression. A class that still exceeds a JVM limit has no + class file: `toBytecode.getOption` is `None`. +- Compiling is stack safe, but Scalus' flat decoder and encoder, which + `CborScript.parse`, `CborScript.of` and `toTyped` call, recurse: on a 1 MB + stack they overflow between 2 000 and 20 000 levels deep, depending on how + warm the JIT is. +- Generated code recurses on the JVM stack where the CEK machine uses the heap, + so `Exec` runs evaluations on a thread with a 512 MB stack. +- Traces are collected (`Result.logs`) but not compared. + +## Running it + +```sh +sbt demoUplcJvm/test +sbt "demoUplcJvm/Test/runMain dev.constructive.eo.demo.uplc.Demo" # the round trip, stage by stage +sbt "demoUplcJvmBench/Jmh/run -prof gc" # JMH: CEK vs generated class +demos/uplc-jvm/scripts/refresh-conformance.sh [plutus-tag] # re-vendor the suite +``` + +`Demo` prints the round trip stage by stage: UPLC text, the typed expression, +the lowered bytecode (as ASM prints it), the class file, and the discharged +result next to the CEK machine's. Pass a directory to also write the +class file there for `javap`. + +## Benchmarks + +`demos/uplc-jvm-bench` is a JMH project (outside the root aggregate and the +library's nightly sweep): the CEK machine against the generated class for every +validator, the Fibonacci puzzle at growing `n`, and what translation itself +costs. The numbers and how they were taken are on the +[docs page](../../site/docs/demos/uplc-jvm.md#benchmarks). + +```sh +sbt "demoUplcJvmBench/Jmh/run -prof gc" +``` + +## Prior art + +Scalus has its own experimental JIT (`scalus-uplc-jit-compiler`, built on +Scala 3 staging). This demo is independent of it: its point is the shape — +one optic from bytes to bytes, a typed intermediate form you can inspect — and +a differential harness that keeps it honest. diff --git a/demos/uplc-jvm/scripts/refresh-conformance.sh b/demos/uplc-jvm/scripts/refresh-conformance.sh new file mode 100755 index 00000000..23332268 --- /dev/null +++ b/demos/uplc-jvm/scripts/refresh-conformance.sh @@ -0,0 +1,47 @@ +#!/usr/bin/env bash +# Re-vendors the Plutus conformance suite's UPLC evaluation cases into the demo's +# test resources. Only the programs (*.uplc) and their expected results +# (*.uplc.expected) are copied: the demo compares results, not budgets. +# +# demos/uplc-jvm/scripts/refresh-conformance.sh [plutus-tag] +# +# Keep the tag in step with the plutus release the pinned Scalus version runs its +# own conformance tests against (Scalus 1.3.0 pins 1.63.0.0 in its flake.nix): +# the corpus grows new builtins and semantics with each release. +set -euo pipefail + +TAG="${1:-1.63.0.0}" +DEMO="$(cd "$(dirname "$0")/.." && pwd)" +DEST="$DEMO/src/test/resources/plutus-conformance" +WORK="$(mktemp -d)" +trap 'rm -rf "$WORK"' EXIT + +git -c advice.detachedHead=false clone --quiet --depth 1 --branch "$TAG" --filter=blob:none --sparse \ + https://github.com/IntersectMBO/plutus "$WORK/plutus" +git -C "$WORK/plutus" sparse-checkout set --no-cone \ + plutus-conformance/test-cases/uplc/evaluation /LICENSE.md /NOTICE.md +COMMIT="$(git -C "$WORK/plutus" rev-parse HEAD)" + +rm -rf "$DEST" +mkdir -p "$DEST/uplc/evaluation" +( + cd "$WORK/plutus/plutus-conformance/test-cases/uplc/evaluation" + find . -type f \( -name '*.uplc' -o -name '*.uplc.expected' \) -print0 | LC_ALL=C sort -z | + tar --null -T - -cf - | tar -xf - -C "$DEST/uplc/evaluation" +) +cp "$WORK/plutus/LICENSE.md" "$DEST/LICENSE.md" +cp "$WORK/plutus/NOTICE.md" "$DEST/NOTICE.md" + +CASES="$(find "$DEST/uplc/evaluation" -name '*.uplc' | wc -l | tr -d ' ')" +cat > "$DEST/SOURCE.md" < Result.Success(Discharge(value, info), ExUnits.zero, Map.empty, logs) + case Failure(bug: AssertionError) => throw bug // a compiler bug is not the program's failure + case Failure(e) => + val error = + if e.isInstanceOf[StackOverflowError] then MachineError("JVM stack exhausted") else e + Result.Failure(error, ExUnits.zero, Map.empty, logs) + } + + /** Plutus V3 validation (CIP-117): the script applied to its context must succeed with unit. */ + def validate(classFile: JvmClassScript, scriptContext: Data): Either[String, Seq[String]] = + run(classFile, List(Constant.Data(scriptContext))) match + case Result.Success(Term.Const(Constant.Unit, _), _, _, logs) => Right(logs) + case Result.Success(other, _, _, _) => + Left(s"script returned a non-unit value: ${other.show}") + case Result.Failure(e, _, _, _) => Left(e.getMessage.nn) + + private[uplc] def onLargeStack[A](body: => A): A = + val task = new FutureTask[A](() => body) + val thread = new Thread(null, task, "uplc-jvm", StackSize) + thread.start() + thread.join() + try task.get() + catch case e: ExecutionException => throw e.getCause diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Expr.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Expr.scala new file mode 100644 index 00000000..567fdf16 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Expr.scala @@ -0,0 +1,174 @@ +package dev.constructive.eo.demo.uplc + +import scala.annotation.tailrec + +import scalus.compiler.sir.PrettyPrinter +import scalus.uplc.{Constant, DefaultFun, DefaultUni} + +/** A static type reconstructed for an untyped UPLC term — the "hybrid" in hybrid typing: the Plutus + * builtin type the typer could prove locally (constants, saturated builtins with a monomorphic + * result, `let`-bound values of those, conditionals whose branches agree), or `None` for + * everything else (functions, constructors, values flowing through lambda parameters). Integers, + * booleans, bytestrings and strings get an unboxed JVM representation; every other value lives in + * the uniform boxed one. + */ +type Ty = Option[DefaultUni] + +object Ty: + + /** What the branches of a conditional agree on. A branch that can only fail does not widen its + * siblings. + */ + def join(branches: List[Expr]): Ty = + branches.filterNot(_.fails).map(_.ty).distinct match + case List(t) => t + case _ => None + +/** The typed, re-sugared program: UPLC read back as a Scala-like expression tree. + * + * The typer recognises the idioms UPLC compilers (Plinth, Scalus, Aiken, …) emit for constructs + * UPLC lacks — `let` as an immediately applied lambda, `if` as a forced `ifThenElse` over delayed + * branches, direct calls of `let`-bound functions — and records them as such. Variables stay de + * Bruijn indices; nodes that can become runtime closures keep the pre-order id (`origin`) of the + * UPLC node they came from, so a closure can be discharged back to source. + */ +final case class TypedProgram private[uplc] (script: CborScript, body: Expr)( + val source: SourceProgram +): + + // The body is a function of the script; comparing two deep trees would recurse. + override def equals(that: Any): Boolean = that match + case t: TypedProgram => t.script == script + case _ => false + + override def hashCode: Int = script.hashCode + +final case class Binding(name: String, rhs: Expr) + +enum Expr: + + /** A variable some enclosing lambda or `let` binds (de Bruijn, 1 = innermost). */ + case Ref(index: Int, binderTy: Ty) + + /** A variable no enclosing binder covers: evaluating it fails, exactly as on the CEK machine. */ + case Unbound(index: Int) + + /** A maximal lambda chain `λp1 … λpn. body`, rooted at UPLC node `origin`. */ + case Lambda(origin: Int, params: List[String], body: Expr) + + /** `delay body`, rooted at UPLC node `origin`. */ + case Delayed(origin: Int, body: Expr) + + /** `(λx1 … λxn. body) a1 … an`: every right-hand side is evaluated in the OUTER scope, in order. + * `origin` is the UPLC lambda the binders came from (used if the body must move to a method). + */ + case Let(origin: Int, bindings: List[Binding], body: Expr, resultTy: Ty) + + /** Dynamic application of an arbitrary function value. */ + case Apply(fn: Expr, arg: Expr) + + /** Saturated call of a `let`-bound lambda chain (UPLC node `origin`): no closure dispatch. */ + case CallKnown(fn: Ref, origin: Int, args: List[Expr]) + + case Force(body: Expr) + + /** The constant at UPLC node `node`. */ + case Lit(node: Int, value: Constant) + + /** An unsaturated builtin used as a value. */ + case BuiltinRef(fun: DefaultFun) + + /** A builtin applied to exactly its forces and arguments. */ + case Call(fun: DefaultFun, args: List[Expr], resultTy: Ty) + + /** `force (ifThenElse c (delay a) (delay b))` and the other selector builtins over delayed + * branches: only the selected branch is evaluated. + */ + case Choose(fun: DefaultFun, scrutinee: Expr, branches: List[Expr], resultTy: Ty) + + case Fail + case Construct(tag: Long, args: List[Expr]) + case Match(scrutinee: Expr, branches: List[Expr], resultTy: Ty) + + def ty: Ty = this match + case Ref(_, t) => t + case Let(_, _, _, t) => t + case Call(_, _, t) => t + case Choose(_, _, _, t) => t + case Match(_, _, t) => t + case Lit(_, c) => Some(c.tpe) + case _ => None + + /** Evaluating it cannot fail and has no effect. */ + def isValue: Boolean = this match + case Ref(_, _) | Lit(_, _) | Lambda(_, _, _) | Delayed(_, _) | BuiltinRef(_) => true + case _ => false + + /** Can only fail: `error`, an unbound variable, or a `let` whose body is one of those. */ + @tailrec final def fails: Boolean = this match + case Fail | Unbound(_) => true + case Let(_, _, body, _) => body.fails + case _ => false + + /** Renders the expression as Scala-like source — for humans; nothing parses it back. */ + def show: String = Expr.block(this, 0, 0) + +object Expr: + + private def scalaType(ty: Ty): String = ty match + case Some(DefaultUni.Integer) => "BigInt" + case Some(DefaultUni.ByteString) => "ByteString" + case Some(DefaultUni.String) => "String" + case Some(DefaultUni.Bool) => "Boolean" + case _ => "Value" + + private def pad(indent: Int): String = " " * indent + + private def name(depth: Int, index: Int): String = s"v${depth - index}" + + /** A statement position (top level, a body, a branch): a `let` renders as its statements. */ + private def block(e: Expr, depth: Int, indent: Int): String = e match + case Let(_, bindings, body, _) => + val defs = bindings.zipWithIndex.map { + case (b, k) => + s"val v${depth + k}: ${scalaType(b.rhs.ty)} = ${render(b.rhs, depth, indent)}" + } + (defs :+ block(body, depth + bindings.size, indent)).mkString(s"\n${pad(indent)}") + case other => render(other, depth, indent) + + private def args(es: List[Expr], depth: Int, indent: Int): String = + es.map(render(_, depth, indent)).mkString(", ") + + private def ifThenElse(cond: Expr, t: Expr, f: Expr, depth: Int, indent: Int): String = + s"if ${render(cond, depth, indent)} then ${block(t, depth, indent + 1)}\n${pad(indent)}else ${block(f, depth, indent + 1)}" + + /** An expression position: a `let` becomes a `{ … }` block. */ + private def render(e: Expr, depth: Int, indent: Int): String = e match + case let: Let => s"{\n${pad(indent + 1)}${block(let, depth, indent + 1)}\n${pad(indent)}}" + case Ref(i, _) => name(depth, i) + case Unbound(i) => s"" + case Lit(_, c) => PrettyPrinter.prettyValue(c).render(100) + case BuiltinRef(fun) => s"builtin.${Semantics.name(fun)}" + case Fail => "error()" + + case Lambda(_, params, body) => + val names = params.indices.map(k => s"v${depth + k}: Value").mkString(", ") + s"($names) =>\n${pad(indent + 1)}${block(body, depth + params.size, indent + 1)}" + + case Delayed(_, body) => s"Lazy(${render(body, depth, indent)})" + case Apply(fn, arg) => s"${render(fn, depth, indent)}(${render(arg, depth, indent)})" + case CallKnown(fn, _, as) => s"${render(fn, depth, indent)}(${args(as, depth, indent)})" + case Force(body) => s"${render(body, depth, indent)}.force" + case Call(fun, as, _) => s"${Semantics.name(fun)}(${args(as, depth, indent)})" + case Construct(tag, as) => s"Constr$tag(${args(as, depth, indent)})" + case Choose(DefaultFun.IfThenElse, cond, List(t, f), _) => ifThenElse(cond, t, f, depth, indent) + case Match(cond, List(f, t), _) if cond.ty.contains(DefaultUni.Bool) => + ifThenElse(cond, t, f, depth, indent) + case Choose(fun, scrut, branches, _) => + s"${Semantics.name(fun)}(${render(scrut, depth, indent)})(${args(branches, depth, indent + 1)})" + case Match(scrut, branches, _) => + val arms = branches.zipWithIndex.map { + case (b, k) => + s"${pad(indent + 1)}case $k => ${block(b, depth, indent + 2)}" + } + s"${render(scrut, depth, indent)} match\n${arms.mkString("\n")}" diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Lower.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Lower.scala new file mode 100644 index 00000000..7e330e22 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Lower.scala @@ -0,0 +1,501 @@ +package dev.constructive.eo.demo.uplc + +import scala.annotation.tailrec +import scala.collection.mutable +import scala.jdk.CollectionConverters.* + +import cats.syntax.traverse.* +import dev.constructive.eo.demo.uplc.runtime.{Dispatch, ProgramInfo} +import org.objectweb.asm.Opcodes.* +import org.objectweb.asm.commons.InstructionAdapter +import org.objectweb.asm.tree.{ClassNode, LdcInsnNode} +import org.objectweb.asm.{Label, MethodVisitor, Type} +import scalus.uplc.builtin.ByteString +import scalus.uplc.{Constant, DefaultFun, DefaultUni} + +/** How generated code holds a value. `Obj` is the uniform boxed representation every UPLC value can + * take — a Scalus `Constant`, or a runtime closure / thunk / partial builtin / constructor; the + * others are unboxed, the JVM classes Scalus' own builtins compute with. + */ +enum Rep(val jvm: Class[?]): + case Obj extends Rep(classOf[AnyRef]) + case Int extends Rep(classOf[BigInt]) + case Bool extends Rep(classOf[Boolean]) + case Bytes extends Rep(classOf[ByteString]) + case Str extends Rep(classOf[String]) + case Data extends Rep(classOf[scalus.uplc.builtin.Data]) + + val asm: Type = Type.getType(jvm) + + /** The runtime's conversions from and to the boxed representation, `Rt.box` / `Rt.un`. + */ + lazy val (box, un) = (s"box$this", s"un$this") + +object Rep: + + def of(ty: Ty): Rep = ty match + case Some(DefaultUni.Integer) => Int + case Some(DefaultUni.Bool) => Bool + case Some(DefaultUni.ByteString) => Bytes + case Some(DefaultUni.String) => Str + case Some(DefaultUni.Data) => Data + case _ => Obj + + def of(jvm: Class[?]): Option[Rep] = values.find(_.jvm == jvm) + +/** Lowers a typed program to its [[JvmClass]] — `UplcJvm.lowering.get`, written straight into ASM's + * class tree: + * + * {{{ + * public final class UplcProgram implements runtime.Dispatch { + * static final ProgramInfo INFO; // the flat program, embedded and re-decoded at class init + * static final Object[] K; // its constants, by node id + * static final UplcProgram INSTANCE; + * public Object run(); // the program + * private static Object m(Object[] env, Object…); // one per lambda chain / delay + * public Object call0/1/2/N(int id, Object[] env, …) // closure dispatch: switch on id + * } + * }}} + * + * - Closure conversion. Every materialised lambda chain / `delay` becomes a static method plus a + * capture array holding exactly its free variables, in [[SourceProgram.captures]] order — the + * order the runtime reads back to discharge closures. + * - Representation. Typed values stay unboxed in locals and on the stack and are boxed only + * where they meet dynamic code. A saturated builtin with a direct implementation + * ([[Semantics.direct]]) is a plain call on its unboxed arguments. + * - Method size. Once a method has inlined enough code, the next `let` body moves to a method of + * its own: the JVM caps a method at 64 KB of bytecode. + */ +object Lower: + + val ClassName = "dev/constructive/eo/demo/uplc/generated/UplcProgram" + + def lower(program: TypedProgram): JvmClass = JvmClass( + new Lowering(program.source).run(program.body) + ) + + /** The script a class embeds: the string constants its static initialiser assembles. */ + def script(cls: JvmClass): CborScript = + val init = cls.node.methods.asScala.filter(_.name == "") + CborScript.fromConstants(init.flatMap(_.instructions.asScala).collect { + case ldc: LdcInsnNode if ldc.cst.isInstanceOf[String] => ldc.cst.toString + }) + + // Descriptors and internal names, made once: ASM hashes every string it is handed. + private[uplc] val Obj = Rep.Obj.asm + private[uplc] val Objs = Type.getType(classOf[Array[AnyRef]]) + private[uplc] val Info = Type.getType(classOf[ProgramInfo]) + private[uplc] val Builtins = Type.getType(Semantics.Builtins.getClass) + + private[uplc] val (self, objs, objName, info) = + (s"L$ClassName;", Objs.getDescriptor, Obj.getInternalName, Info.getInternalName) + + private[uplc] val (builtins, builtinsModule) = (Builtins.getInternalName, Builtins.getDescriptor) + private[uplc] val Rt = "dev/constructive/eo/demo/uplc/runtime/Rt" + + /** `Rt`'s entry points, name ⇒ descriptor (each name is unique). */ + private[uplc] val rt = java.util.HashMap[String, String]() + Class.forName(Rt.replace('/', '.')).getMethods.foreach(m => rt.put(m.getName, desc(m))) + + private def desc(m: java.lang.reflect.Method) = Type.getMethodDescriptor(m) + + /** A builtin's direct implementation (see [[Semantics.direct]]), as generated code calls it. */ + final case class Direct(owner: String, name: String, desc: String, args: List[Rep], result: Rep) + + private[uplc] val direct: IArray[Option[Direct]] = IArray.from(DefaultFun.values.map { f => + for + m <- Semantics.direct(f) + args <- m.getParameterTypes.toList.traverse(Rep.of) + result <- Rep.of(m.getReturnType) + yield Direct(Type.getInternalName(m.getDeclaringClass), m.getName, desc(m), args, result) + }) + + /** `m(Object[] env, Object × arity)`. */ + private[uplc] val descriptors = IArray.tabulate(Typer.MaxChain + 1)(n => + Type.getMethodDescriptor(Obj, (Objs +: Seq.fill(n)(Obj))*) + ) + +/** Where a variable lives in the method being written. */ +private enum Loc: + case Slot(slot: Int, rep: Rep) + case Env(index: Int) + + /** A pure value (a builtin, maybe forced): computed where it is read, never if it is not. */ + case Pure(value: Expr) + + /** Bound in the program but not captured by this method — never referenced from it. */ + case Absent + +/** One method being written: its next free local slot, and how many expression nodes it has inlined + * so far. Every representation fits one slot. + */ +final private class Gen(mv: MethodVisitor, var next: Int) extends InstructionAdapter(ASM9, mv): + var size: Int = 0 + + /** Pops the top of the stack into a fresh local. */ + def local(t: Type): Int = + store(next, t) + next += 1 + next - 1 + +/** Lowering, as [[Step]]s: however deep a program nests, the JVM stack stays shallow. Every + * function writes its instructions as it is called, and what must follow a subexpression is a step + * after it; the walk recurses through [[genAs]], which goes deeper with [[Walk.nested]]. + */ +final private class Lowering(source: SourceProgram): + + import Lower.* + import Step.{Done, all, each} + + private val walk = new Walk + + /** Expression nodes one method may inline before the next `let` body moves to a method. */ + private val OutlineAfter = 1500 + + private val cls = new ClassNode + private val closures = mutable.ArrayBuffer.empty[(Int, Int)] // (method id, arity; 0 = delay) + private val lambdaMethods = mutable.HashMap.empty[Int, Int] // origin -> method id + + def run(program: Expr): ClassNode = + val dispatch = Array(Type.getInternalName(classOf[Dispatch])) + cls.visit(V17, ACC_PUBLIC | ACC_FINAL | ACC_SUPER, ClassName, null, objName, dispatch) + for (name, desc) <- List("INFO" -> Info.getDescriptor, "K" -> objs, "INSTANCE" -> self) do + cls.visitField(ACC_PUBLIC | ACC_STATIC | ACC_FINAL, name, desc, null, null) + method(ACC_PUBLIC, "", "()V") { g ?=> + g.visitVarInsn(ALOAD, 0) + g.invokespecial(objName, "", "()V", false) + Step.unit + }.value + method(ACC_STATIC, "", "()V")(staticInit).value + method(ACC_PUBLIC, "run", Type.getMethodDescriptor(Obj))( + genAs(program, Rep.Obj, Vector.empty) + ).value + for (name, arity) <- List("call0" -> 0, "call1" -> 1, "call2" -> 2, "callN" -> -1) do + val targets = closures.filter((_, a) => if arity < 0 then a > 0 else a == arity).toMap + val extra = if arity < 0 then List(Objs) else List.fill(arity)(Obj) + method(ACC_PUBLIC, name, Type.getMethodDescriptor(Obj, Type.INT_TYPE :: Objs :: extra*)) { + g ?=> + // callK(int id, Object[] env, …): a switch from method id to closure body. + g.load(1, Type.INT_TYPE) + switch(targets.keys.toVector.sorted) { id => + g.load(2, Objs) + if arity >= 0 then (1 to arity).foreach(i => g.load(2 + i, Obj)) + else (0 until targets(id)).foreach(element(g.load(3, Objs), _)) + invokeBody(id, targets(id)) + Step.unit + } + }.value + cls + + /** Writes a method whose first free local slot is `next`. */ + private def method(access: Int, name: String, desc: String, next: Int = 1)( + body: Gen ?=> Step[Unit] + ): Step[Unit] = + val g = Gen(cls.visitMethod(access, name, desc, null, null), next) + g.visitCode() + body(using g).map { _ => + g.visitInsn(if desc.endsWith("V") then RETURN else ARETURN) + g.visitMaxs(0, 0) + g.visitEnd() + } + + /** Loads the embedded script and its constants, and creates `INSTANCE`. */ + private def staticInit(using g: Gen): Step[Unit] = + objects(source.script.asConstants) { c => + g.aconst(c) + Step.unit + }.map { _ => + g.invokestatic(info, "fromConstants", Type.getMethodDescriptor(Info, Objs), false) + g.dup() + g.putstatic(ClassName, "INFO", Info.getDescriptor) + g.invokevirtual(info, "constants", Type.getMethodDescriptor(Objs), false) + g.putstatic(ClassName, "K", objs) + g.visitTypeInsn(NEW, ClassName) + g.dup() + g.invokespecial(ClassName, "", "()V", false) + g.putstatic(ClassName, "INSTANCE", self) + } + + private def element(array: => Unit, i: Int)(using g: Gen): Unit = + array + g.iconst(i) + g.visitInsn(AALOAD) + + /** An `Object[]` of `items`, evaluated in order. */ + private def objects[A](items: Iterable[A])(item: A => Step[Unit])(using g: Gen): Step[Unit] = + g.iconst(items.size) + g.visitTypeInsn(ANEWARRAY, objName) + each(items.zipWithIndex) { (a, i) => + g.dup() + g.iconst(i) + item(a).map(_ => g.visitInsn(AASTORE)) + } + + private def call(name: String)(using g: Gen): Unit = g.invokestatic(Rt, name, rt.get(name), false) + + /** A runtime call whose result is a boxed value. */ + private def obj(name: String)(using Gen): Rep = + call(name) + Rep.Obj + + private def invokeBody(id: Int, arity: Int)(using g: Gen): Unit = + g.invokestatic(ClassName, cls.methods.get(id).name, descriptors(arity), false) + + private def fail(reason: String)(using g: Gen): Rep = + g.aconst(reason) + call("fail") + g.athrow() + Rep.Obj + + /** Converts between representations. Mismatched scalars go through a box, so an ill-typed program + * fails at run time, as on the CEK machine. + */ + private def convert(from: Rep, to: Rep)(using Gen): Unit = + if from != to then + if from != Rep.Obj then call(from.box) + if to != Rep.Obj then call(to.un) + + private def load(scope: Vector[Loc], index: Int)(using g: Gen): Step[Rep] = + scope(scope.size - index) match + case Loc.Slot(slot, rep) => + g.load(slot, rep.asm) + Done(rep) + case Loc.Env(k) => + element(g.visitVarInsn(ALOAD, 0), k) + Done(Rep.Obj) + case Loc.Pure(value) => gen(value, Vector.empty) + // Captures are the free variables of the source term, and every variable a nested closure + // needs is free in its parent too — so this is unreachable. + case Loc.Absent => throw new IllegalStateException(s"variable $index is not captured") + + private def values(es: Seq[Expr], scope: Vector[Loc])(using Gen): Step[Unit] = + objects(es)(genAs(_, Rep.Obj, scope)) + + /** The capture array for a closure rooted at `origin`. */ + private def env(origin: Int, scope: Vector[Loc])(using Gen): Step[Unit] = + val captures = source.captures(origin) + if captures.isEmpty then + call("noCaptures") + Step.unit + else objects(captures.toSeq)(j => load(scope, j).map(convert(_, Rep.Obj))) + + /** Writes the body method of a closure rooted at `origin` with `arity` parameters (a `delay` has + * none), registered with the dispatchers when it is a `closure`, and returns its id. The body + * sees exactly the captured variables, then the parameters. + */ + private def outline( + origin: Int, + arity: Int, + e: Expr, + scope: Vector[Loc], + closure: Boolean, + ): Step[Int] = + val inner = + source.captures(origin).zipWithIndex.foldLeft(Vector.fill[Loc](scope.size)(Loc.Absent)) { + case (acc, (j, k)) => acc.updated(scope.size - j, Loc.Env(k)) + } ++ (1 to arity).map(Loc.Slot(_, Rep.Obj)) + val id = cls.methods.size + if closure then + closures += ((id, arity)) + lambdaMethods(origin) = id // before the body: a recursive body calls itself directly + method(ACC_PRIVATE | ACC_STATIC, s"m$id", descriptors(arity), arity + 1)( + genAs(e, Rep.Obj, inner) + ).map(_ => id) + + private def closure(id: Int, origin: Int, arity: Int, scope: Vector[Loc])(using + g: Gen + ): Step[Rep] = + g.getstatic(ClassName, "INSTANCE", self) + g.iconst(id) + g.iconst(origin) + g.iconst(arity) + env(origin, scope).map(_ => obj("closure")) + + /** Emits `e` in representation `rep`. */ + private def genAs(e: Expr, rep: Rep, scope: Vector[Loc])(using g: Gen): Step[Unit] = + walk.nested(e match + case Expr.Let(origin, bindings, body, _) if g.size > OutlineAfter => + // The body becomes the body method of the let's own lambda, called directly. + for + _ <- env(origin, scope) + _ <- each(bindings)(b => genAs(b.rhs, Rep.Obj, scope)) + id <- outline(origin, bindings.size, body, scope, closure = false) + yield + invokeBody(id, bindings.size) + convert(Rep.Obj, rep) + case Expr.Let(_, bindings, body, _) => + // Right-hand sides see the outer scope only, and run in order. + all(bindings) { b => + if pure(b.rhs, 0) then Done(Loc.Pure(b.rhs)) + else + val r = Rep.of(b.rhs.ty) + genAs(b.rhs, r, scope).map(_ => Loc.Slot(g.local(r.asm), r)) + }.flatMap(bound => genAs(body, rep, scope ++ bound)) + + case Expr.Choose(DefaultFun.IfThenElse, cond, List(t, f), _) + if cond.ty.contains(DefaultUni.Bool) => + genAs(cond, Rep.Bool, scope) >> branch(genAs(t, rep, scope), genAs(f, rep, scope)) + case Expr.Choose(fun, scrut, branches, _) => + g.iconst(fun.ordinal) + genAs(scrut, Rep.Obj, scope) >> { + g.iconst(branches.size) + call("chooseIndex") + switch(branches.indices)(i => genAs(branches(i), rep, scope)) + } + + case Expr.Match(scrut, branches, _) if scalar(scrut, DefaultUni.Bool) => + genAs(scrut, Rep.Bool, scope) >> (branches match + case List(f, t) => branch(genAs(t, rep, scope), genAs(f, rep, scope)) + case List(f) => + branch(Done(fail("case on True needs a second branch"): Unit), genAs(f, rep, scope)) + case _ => Done(fail("case on a boolean needs 1 or 2 branches"): Unit)) + case Expr.Match(scrut, branches, _) if scalar(scrut, DefaultUni.Integer) => + genAs(scrut, Rep.Int, scope) >> { + g.iconst(branches.size) + call("integerCaseIndex") + switch(branches.indices)(i => genAs(branches(i), rep, scope)) + } + + case _ => gen(e, scope).map(convert(_, rep))) + + /** A builtin forced no more often than it takes type arguments: nothing to evaluate or fail. */ + @tailrec + private def pure(e: Expr, forces: Int): Boolean = e match + case Expr.Force(inner) => pure(inner, forces + 1) + case Expr.BuiltinRef(f) => forces <= Semantics.scheme(f).numTypeVars + case _ => false + + /** PV11 casing on a known scalar compiles to a JVM branch or switch. */ + private def scalar(scrut: Expr, uni: DefaultUni): Boolean = + Semantics.caseOnBuiltins && scrut.ty.contains(uni) + + /** An `if` on the boolean on the stack. */ + private def branch(whenTrue: => Step[Unit], whenFalse: => Step[Unit])(using g: Gen): Step[Unit] = + val (otherwise, end) = (new Label, new Label) + g.ifeq(otherwise) + whenTrue >> { + g.goTo(end) + g.mark(otherwise) + whenFalse.map(_ => g.mark(end)) + } + + /** A switch on the int on the stack, one arm per key (ascending). The runtime only ever produces + * one of the keys, so the last arm doubles as the default; with no keys it never returns. + */ + private def switch(keys: Seq[Int])(arm: Int => Step[Unit])(using g: Gen): Step[Unit] = + val (labels, end) = (keys.map(_ => new Label).toArray, new Label) + if keys.isEmpty then + g.pop() + fail("no branches"): Unit + else g.lookupswitch(labels.last, keys.toArray, labels) + each(keys.zip(labels)) { (k, l) => + g.mark(l) + arm(k).map(_ => g.goTo(end)) + }.map(_ => g.mark(end)) + + /** Emits `e` in its natural representation and returns it. */ + private def gen(e: Expr, scope: Vector[Loc])(using g: Gen): Step[Rep] = + g.size += 1 + e match + case Expr.Ref(i, _) => load(scope, i) + case Expr.Unbound(i) => Done(fail(s"open term: variable $i is not bound")) + case Expr.Fail => Done(fail("error")) + + case Expr.Lit(_, Constant.Bool(b)) => + g.iconst(if b then 1 else 0) + Done(Rep.Bool) + case Expr.Lit(node, _) => + // Constants live boxed in the class's table, and are unboxed where a typed use reads them. + element(g.getstatic(ClassName, "K", objs), node) + Done(Rep.Obj) + + case Expr.Lambda(origin, params, body) => + outline(origin, params.size, body, scope, closure = true) + .flatMap(closure(_, origin, params.size, scope)) + case Expr.Delayed(origin, body) => + outline(origin, 0, body, scope, closure = true).flatMap(closure(_, origin, 0, scope)) + + case Expr.Apply(fn, arg) => + genAs(fn, Rep.Obj, scope) >> genAs(arg, Rep.Obj, scope).map(_ => obj("apply")) + case Expr.Force(body) => genAs(body, Rep.Obj, scope).map(_ => obj("force")) + case Expr.CallKnown(fn, origin, args) => + load(scope, fn.index) + .flatMap { r => + convert(r, Rep.Obj) + call("envOf") + each(args)(genAs(_, Rep.Obj, scope)) + } + .map { _ => + invokeBody(lambdaMethods(origin), args.size) + Rep.Obj + } + + case Expr.BuiltinRef(fun) => + g.iconst(fun.ordinal) + Done(obj("builtin")) + case Expr.Call(fun, args, _) => + direct(fun.ordinal) match + case Some(d) => + // Outside `Rt`, a direct implementation is a method of Scalus' `Builtins` object. + if d.owner != Rt then g.getstatic(builtins, "MODULE$", builtinsModule) + each(args.zip(d.args))((a, r) => genAs(a, r, scope)).map { _ => + if d.owner == Rt then g.invokestatic(Rt, d.name, d.desc, false) + else g.invokevirtual(d.owner, d.name, d.desc, false) + d.result + } + case None => + g.iconst(fun.ordinal) + values(args, scope).map(_ => obj("call")) + + case Expr.Construct(tag, args) => + g.lconst(tag) + values(args, scope).map(_ => obj("construct")) + + case Expr.Match(scrut, branches, _) + if !scalar(scrut, DefaultUni.Bool) && !scalar(scrut, DefaultUni.Integer) => + caseOf(scrut, branches, scope) + case _ => + val rep = Rep.of(e.ty) + genAs(e, rep, scope).map(_ => rep) + + /** A dynamic `case`: the runtime picks the branch and hands it the scrutinee's fields. A branch + * that is a lambda chain of the right arity is called directly. + */ + private def caseOf(scrut: Expr, branches: List[Expr], scope: Vector[Loc])(using + g: Gen + ): Step[Rep] = + genAs(scrut, Rep.Obj, scope).flatMap { _ => + g.dup() + call("caseFields") + val fields = g.local(Objs) + g.iconst(branches.size) + call("caseIndex") + switch(branches.indices) { i => + branches(i) match + case Expr.Lambda(origin, params, lambdaBody) => + val arity = params.size + val (generic, end) = (new Label, new Label) + outline(origin, arity, lambdaBody, scope, closure = true).flatMap { id => + g.load(fields, Objs) + g.arraylength() + g.iconst(arity) + g.ificmpne(generic) + env(origin, scope).flatMap { _ => + (0 until arity).foreach(element(g.load(fields, Objs), _)) + invokeBody(id, arity) + g.goTo(end) + g.mark(generic) + closure(id, origin, arity, scope).map { _ => + g.load(fields, Objs) + call("applyAll") + g.mark(end) + } + } + } + case other => + genAs(other, Rep.Obj, scope).map { _ => + g.load(fields, Objs) + call("applyAll") + } + }.map(_ => Rep.Obj) + } diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Scripts.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Scripts.scala new file mode 100644 index 00000000..4eeee87e --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Scripts.scala @@ -0,0 +1,87 @@ +package dev.constructive.eo.demo.uplc + +import scala.util.Try + +import java.util.Base64 +import org.objectweb.asm.tree.ClassNode +import scalus.uplc.builtin.ByteString +import scalus.uplc.{DeBruijnedProgram, Program} + +// What the compiler's optics focus on, besides the typed program. The two byte encodings at its ends +// are Scalus' `ByteString` underneath — bytes with value equality, so the optics' round-trip laws +// can compare them with `==`. None of the three hands out what it holds, only copies: a value +// cannot change after the compiler made or checked it, so the way back always works. + +/** A Plutus script as the ledger stores it: the flat-encoded program, wrapped in a CBOR bytestring. + * Every value is well formed: [[CborScript.of]] encoded it, or [[CborScript.parse]] checked it. + */ +opaque type CborScript = ByteString + +object CborScript: + + /** A Scalus program, flat-encoded. Scalus' encoder throws on a program it cannot encode — one + * with a free variable; this is the one place that becomes a value. + */ + def of(program: Program): Either[String, CborScript] = + Try(ByteString.fromArray(program.cborEncoded)) + .toEither + .left + .map(e => s"no flat encoding: ${e.getMessage}") + + /** Bytes of unknown provenance. Scalus' decoder throws on malformed input; this is the one place + * that becomes a value. + */ + def parse(cbor: Array[Byte]): Either[String, CborScript] = + val script = ByteString.fromArray(cbor) // checked after copying: the caller keeps `cbor` + Try(DeBruijnedProgram.fromCbor(script.bytes)).toEither match + case Left(e) => Left(s"not a CBOR-wrapped flat UPLC script: ${e.getMessage}") + case Right(_) => Right(script) + + /** The script back from the string constants [[asConstants]] stored it in. */ + private[uplc] def fromConstants(constants: Iterable[String]): CborScript = + ByteString.fromArray(Base64.getDecoder.decode(constants.mkString)) + + extension (script: CborScript) + def bytes: Array[Byte] = script.bytes.clone + + private[uplc] def program: DeBruijnedProgram = DeBruijnedProgram.fromCbor(script.bytes) + + /** The script as class-file string constants. A compiled class carries the script it was + * compiled from — that is how `lowering` walks back, and what the runtime re-decodes to turn + * results back into terms. A class file has no byte-array constants, so the script is stored + * as text: Base64, whose characters take one byte each in a class file, cut into pieces of at + * most 65535 characters, the most one string constant holds. + */ + private[uplc] def asConstants: Seq[String] = + Base64.getEncoder.encodeToString(script.bytes).grouped(65535).toSeq + +/** A class file this compiler wrote for a script: its JVM code, and the script itself. Only the + * compiler makes one ([[UplcJvm.toBytecode]]), and the script comes back out of it. + */ +opaque type JvmClassScript = ByteString + +object JvmClassScript: + + private[uplc] def apply(classFile: Array[Byte]): JvmClassScript = ByteString.fromArray(classFile) + + extension (classFile: JvmClassScript) def bytes: Array[Byte] = classFile.bytes.clone + +/** A script's JVM class in memory — ASM's class tree, as the compiler builds it or as ASM reads it + * back from the class file ([[UplcJvm.decompile]]). Only those two make one, so it always embeds + * its script. + */ +opaque type JvmClass = ClassNode + +object JvmClass: + + private[uplc] def apply(tree: ClassNode): JvmClass = tree + + extension (cls: JvmClass) + + /** A copy of ASM's tree, to inspect or print the bytecode. */ + def tree: ClassNode = + val copy = new ClassNode + cls.accept(copy) + copy + + private[uplc] def node: ClassNode = cls diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Semantics.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Semantics.scala new file mode 100644 index 00000000..b92c2a86 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Semantics.scala @@ -0,0 +1,93 @@ +package dev.constructive.eo.demo.uplc + +import scala.annotation.tailrec + +import java.lang.reflect.Method +import scalus.cardano.ledger.MajorProtocolVersion +import scalus.uplc.builtin.platform +import scalus.uplc.eval.PlutusVM +import scalus.uplc.{BuiltinRuntime, CardanoBuiltins, DefaultFun, DefaultUni, TypeScheme} +import scalus.utils.Utils + +/** The single Plutus semantics this demo targets — Plutus V3 at protocol version 11 ("van Rossem"), + * builtin semantics variant E, the same configuration Scalus 1.3.0 runs the Plutus conformance + * suite under. The oracle VM and the generated code's runtime both read it from here, so they + * cannot drift apart. + */ +object Semantics: + + val protocolVersion: MajorProtocolVersion = MajorProtocolVersion.vanRossemPV + + /** The Plutus Core versions a script may declare: those Plutus V3 has at [[protocolVersion]] + * (`plcVersionsIntroducedIn` in plutus-ledger-api). A version only gates syntax — 1.1.0 adds + * `constr` and `case`, which Scalus' codec refuses below it — but the ledger rejects a script of + * any other version when it decodes it, and so does the compiler. + */ + val versions: Set[(Int, Int, Int)] = Set((1, 0, 0), (1, 1, 0)) + + /** The oracle: Scalus' CEK machine, configured for [[protocolVersion]]. */ + lazy val vm: PlutusVM = PlutusVM.makePlutusV3VM(protocolVersion) + + /** PV11 lets `case` scrutinise builtin values (integers, booleans, unit, lists, pairs). */ + val caseOnBuiltins: Boolean = protocolVersion >= MajorProtocolVersion.vanRossemPV + + /** Casing on `Data` arrives one hard fork later (PV12). */ + val caseOnData: Boolean = protocolVersion >= MajorProtocolVersion.dijkstraPV + + private lazy val cardanoBuiltins = + new CardanoBuiltins(vm.machineParams.builtinCostModel, platform, vm.semanticVariant) + + private lazy val runtimes: IArray[BuiltinRuntime] = + IArray.from(DefaultFun.values.iterator.map(cardanoBuiltins.getBuiltinRuntime)) + + /** Scalus' implementation of a builtin — what generated code delegates to. */ + def runtime(fun: DefaultFun): BuiltinRuntime = runtimes(fun.ordinal) + + /** A builtin's type. Builtins are prenex-polymorphic: `numTypeVars` forces, then `arity` + * arguments, and the builtin runs when the last of them arrives. + */ + def scheme(fun: DefaultFun): TypeScheme = runtime(fun).typeScheme + + /** The type of a builtin's saturated result, given what is known of its arguments: matching them + * against the scheme binds its type variables (`fstPair` of a `pair integer (list data)` is an + * `integer`). + */ + def result(fun: DefaultFun, args: List[Ty]): Ty = + def bind(s: TypeScheme, t: DefaultUni, vars: Map[String, DefaultUni]): Map[String, DefaultUni] = + (s, t) match + case (TypeScheme.TVar(a), _) => vars.updated(a, t) + case (TypeScheme.App(f, x), DefaultUni.Apply(g, y)) => bind(x, y, bind(f, g, vars)) + case _ => vars + def subst(s: TypeScheme, vars: Map[String, DefaultUni]): Ty = s match + case TypeScheme.Type(uni) => Some(uni) + case TypeScheme.TVar(a) => vars.get(a) + case TypeScheme.App(f, x) => subst(f, vars).zip(subst(x, vars)).map(DefaultUni.Apply(_, _)) + case _ => None + @tailrec + def go(s: TypeScheme, args: List[Ty], vars: Map[String, DefaultUni]): Ty = (s, args) match + case (TypeScheme.All(_, rest), _) => go(rest, args, vars) + case (TypeScheme.Arrow(p, rest), a :: as) => go(rest, as, a.fold(vars)(bind(p, _, vars))) + case _ => subst(s, vars) + go(scheme(fun), args, Map.empty) + + /** Scalus' plain implementations of the builtins — the functions its CEK meanings wrap. */ + val Builtins: scalus.uplc.builtin.Builtins = scalus.uplc.builtin.Builtins + + /** A builtin's direct implementation, if it has one: a method of the builtin's name on the + * runtime's `Rt` or else on [[Builtins]], taking one parameter per argument, each — like its + * result — in a representation generated code has. Generated code calls it instead of the CEK + * meaning, on unboxed values where the signature allows. `shiftByteString` and + * `rotateByteString` keep their meanings, which add variant-E range checks to the functions. + */ + def direct(fun: DefaultFun): Option[Method] = + def on(c: Class[?]) = c + .getMethods + .find(m => + m.getName == name(fun) && m.getParameterCount == scheme(fun).arity && + (m.getReturnType +: m.getParameterTypes).forall(Rep.of(_).isDefined) + ) + if fun == DefaultFun.ShiftByteString || fun == DefaultFun.RotateByteString then None + else on(Class.forName("dev.constructive.eo.demo.uplc.runtime.Rt")).orElse(on(Builtins.getClass)) + + /** The UPLC spelling of a builtin (`addInteger`); Scalus' enum cases are capitalised. */ + def name(fun: DefaultFun): String = Utils.lowerFirst(fun.toString) diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/SourceProgram.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/SourceProgram.scala new file mode 100644 index 00000000..14fca961 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/SourceProgram.scala @@ -0,0 +1,92 @@ +package dev.constructive.eo.demo.uplc + +import scala.collection.concurrent.TrieMap +import scala.collection.immutable.SortedSet + +import scalus.uplc.Term + +/** A decoded script — Scalus' own `Term` tree — numbered in PRE-ORDER. + * + * The numbering is the contract between compile time and run time. The compiler stamps node ids + * into the typed expression and from there into the generated class; the runtime re-decodes the + * same script (it is embedded in the class) and gets the same numbering back. A closure therefore + * only has to carry an `Int` to be turned back into its source term — which is what discharging a + * result (and comparing it with the CEK machine's) needs. Constants are looked up by node id too. + * + * Every node gets an id: the node itself first, then its children left to right (`LamAbs` body; + * `Apply` function then argument; `Constr` arguments; `Case` scrutinee then branches). A lambda + * chain `λx.λy.b` therefore occupies consecutive ids — the inner lambda of a chain rooted at `o` + * is `o + 1`, which partial applications rely on — and a node's next sibling comes right after its + * subtree. + */ +final class SourceProgram private ( + val script: CborScript, + val version: (Int, Int, Int), + val nodes: IArray[Term], + val depths: IArray[Int], + sizes: IArray[Int], +): + + /** The ids of node `n`'s children, in order: each starts where the one before it ends, until the + * end of `n`'s subtree. + */ + def children(n: Int): List[Int] = + List.unfold(n + 1)(c => Option.when(c < n + sizes(n))((c, c + sizes(c)))) + + private val captureCache = TrieMap.empty[Int, IArray[Int]] + + /** The variables a closure created at node `origin` must capture, in capture-array order. + * + * These are the free de Bruijn indices of the node — relative to the node's own position — that + * some enclosing binder actually binds, ascending. Indices past the program's binders are open: + * they are never captured and fail only if evaluation reaches them. Compile time (which builds + * the capture array) and run time (which reads it back while discharging) both ask this one + * function, so the two can never disagree on the layout. + */ + def captures(origin: Int): IArray[Int] = captureCache.getOrElseUpdate( + origin, + // The node's subtree is the ids from `origin` on; a variable there is free in the node when its + // index reaches past the binders between the two. + IArray.from((origin until origin + sizes(origin)).foldLeft(SortedSet.empty[Int]) { (free, n) => + nodes(n) match + case Term.Var(name, _) => + val index = name.index - (depths(n) - depths(origin)) + if index >= 1 && index <= depths(origin) then free + index else free + case _ => free + }) + ) + +object SourceProgram: + + def decode(script: CborScript): SourceProgram = + // A subtree's nodes, binder depths and subtree sizes in pre-order, ahead of the `count` nodes + // after it: a right fold over the children. + type Numbered = (List[Term], List[Int], List[Int], Int) + val walk = new Walk + def number(term: Term, depth: Int, rest: Numbered): Step[Numbered] = walk.nested { + val inner = if term.isInstanceOf[Term.LamAbs] then depth + 1 else depth + subterms(term) + .foldRight(Step.Done(rest): Step[Numbered])((t, acc) => acc.flatMap(number(t, inner, _))) + .map((ns, ds, ss, count) => + (term :: ns, depth :: ds, (count - rest._4 + 1) :: ss, count + 1) + ) + } + val program = script.program + val (nodes, depths, sizes, _) = number(program.term, 0, (Nil, Nil, Nil, 0)).value + new SourceProgram( + script, + program.version, + IArray.from(nodes), + IArray.from(depths), + IArray.from(sizes), + ) + + /** A term's immediate subterms, in the order they are numbered. */ + def subterms(term: Term): List[Term] = term match + case Term.LamAbs(_, body, _) => List(body) + case Term.Apply(fn, arg, _) => List(fn, arg) + case Term.Force(body, _) => List(body) + case Term.Delay(body, _) => List(body) + case Term.Constr(_, args, _) => args + case Term.Case(scrut, cases, _) => scrut :: cases + case _: Term.Var | _: Term.Const | _: Term.Builtin | _: Term.Error => Nil diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Step.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Step.scala new file mode 100644 index 00000000..2f7467d9 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Step.scala @@ -0,0 +1,71 @@ +package dev.constructive.eo.demo.uplc + +import cats.Eval + +/** One step of a compiler walk — decoding, typing, lowering: each recurses as deep as the program + * nests. A step is [[Step.Done]], or [[Step.Later]], on the heap. + * + * A walk makes plain calls while it is shallow: a done step's `flatMap` calls straight on. Once it + * is [[Walk.Deep]] calls deep it defers ([[Walk.nested]]), and the rest runs from `cats.Eval`'s + * loop, at the bottom of the JVM stack. So no program overflows the stack, and a shallow one pays + * next to nothing for that. + * + * Every step runs once, and only after the steps before it — so a step may do its work as it is + * made: the lowering writes instructions that way. + */ +enum Step[+A]: + case Done(a: A) + case Later(steps: Eval[A]) + + def flatMap[B](f: A => Step[B]): Step[B] = this match + case Done(a) => f(a) + case Later(e) => Later(e.flatMap(f(_).eval)) + + def map[B](f: A => B): Step[B] = this match + case Done(a) => Done(f(a)) + case Later(e) => Later(e.map(f)) + + def >>[B](next: => Step[B]): Step[B] = this match + case Done(_) => next + case Later(e) => Later(e.flatMap(_ => next.eval)) + + def eval: Eval[A] = this match + case Done(a) => Eval.now(a) + case Later(e) => e + + def value: A = eval.value + +object Step: + + val unit: Step[Unit] = Done(()) + + def each[A](as: Iterable[A])(step: A => Step[Unit]): Step[Unit] = + as.foldLeft(unit)((acc, a) => acc >> step(a)) + + def all[A, B](as: List[A])(step: A => Step[B]): Step[List[B]] = + as.foldLeft(Done(List.empty[B]): Step[List[B]])((acc, a) => + acc.flatMap(bs => step(a).map(_ :: bs)) + ).map(_.reverse) + +/** How deep a walk is on the JVM stack: every recursive call of a walk goes through [[nested]]. */ +final class Walk: + + private var depth = 0 + + /** `step`, made now while the walk is shallow; once it is [[Walk.Deep]] calls deep, made later, + * from the bottom of the stack. + */ + def nested[A](step: => Step[A]): Step[A] = + if depth >= Walk.Deep then Step.Later(Eval.defer(step.eval)) + else + depth += 1 + val made = step + depth -= 1 + made + +object Walk: + + /** Nested calls a walk makes on the JVM stack before it defers: a few frames each, far from the + * smallest stack a thread gets. + */ + val Deep = 128 diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Typer.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Typer.scala new file mode 100644 index 00000000..1419a802 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/Typer.scala @@ -0,0 +1,264 @@ +package dev.constructive.eo.demo.uplc + +import scala.annotation.tailrec + +import dev.constructive.eo.demo.uplc.Step.{all, Done} +import scalus.uplc.{DefaultFun, DefaultUni, Term} + +/** `UplcJvm.toTyped`'s way in: reads a decoded UPLC program back as a typed, Scala-like [[Expr]], + * walking it by node id. + * + * Every rewrite here is an exact equivalence under the CEK machine's evaluation order — they only + * remove steps that cannot be observed (building a closure that is immediately applied, delaying a + * branch that is immediately forced, partially applying a builtin that is immediately saturated). + * Effects keep their order; anything the typer does not recognise stays a dynamic `Apply` / + * `Force` and is executed exactly as the machine would. + * + * The walk is made of [[Step]]s: however deep a program nests, the JVM stack stays shallow. + */ +object Typer: + + /** Longest lambda chain compiled into one JVM method (the JVM caps a method at 255 parameter + * slots, one of which holds the captured environment). + */ + val MaxChain = 200 + + def typeProgram(source: SourceProgram): TypedProgram = + TypedProgram(source.script, new Typing(source).expr(0, Vector.empty).value)(source) + +/** What a binder is statically known to hold. */ +private enum Known: + case Unknown + + /** A lambda chain (UPLC node `origin`): saturated calls go straight to its body method. */ + case Lambda(origin: Int, arity: Int) + + /** A builtin, already forced `forces` times: calls through the variable are builtin calls. */ + case Builtin(fun: DefaultFun, forces: Int) + +/** What the typer knows about a binder: its static type and what value it holds. */ +final private case class Binder(ty: Ty, known: Known) + +/** One link of an application spine, innermost first: an argument (its node id) or a force. */ +private enum Link: + case Arg(node: Int) + case Frc + +final private class Typing(source: SourceProgram): + + import source.{children, nodes} + + private val walk = new Walk + + private val Param = Binder(None, Known.Unknown) + + /** Builtins that return one of their arguments after the first unchanged: over delayed branches, + * only the branch they pick runs. + */ + private val selectors = + Set(DefaultFun.IfThenElse, DefaultFun.ChooseList, DefaultFun.ChooseUnit, DefaultFun.ChooseData) + + private def lookup(scope: Vector[Binder], index: Int): Option[Binder] = + if index >= 1 && index <= scope.size then Some(scope(scope.size - index)) else None + + def expr(n: Int, scope: Vector[Binder]): Step[Expr] = nodes(n) match + case Term.Var(name, _) => + Done( + lookup(scope, name.index).fold(Expr.Unbound(name.index))(b => Expr.Ref(name.index, b.ty)) + ) + case Term.Const(value, _) => Done(Expr.Lit(n, value)) + case Term.Builtin(fun, _) => Done(Expr.BuiltinRef(fun)) + case Term.Error(_) => Done(Expr.Fail) + case _ => walk.nested(compound(n, scope)) + + private def compound(n: Int, scope: Vector[Binder]): Step[Expr] = nodes(n) match + case _: Term.LamAbs => lambda(n, scope, recursive = false) + case _: Term.Delay => expr(n + 1, scope).map(Expr.Delayed(n, _)) + case Term.Constr(tag, _, _) => + all(children(n))(expr(_, scope)).map(strict(_)(Expr.Construct(tag.value, _))) + case Term.Case(scrut, _, _) => + val s :: branches = children(n): @unchecked + scrut match + // case (constr k a1 … an) [… f …]: the multi-argument call compilers emit. The fields are + // evaluated first, then the branch, then the branch is applied to them — an ordinary + // application when nothing observable can run in between (see `applies`). + case Term.Constr(tag, fields, _) + if tag.value >= 0 && tag.value < branches.size && + applies(branches(tag.value.toInt), fields.size, scope) => + application(branches(tag.value.toInt), children(s).map(Link.Arg(_)), scope) + case _ => + for e <- expr(s, scope); bs <- all(branches)(expr(_, scope)) + yield + // Only a case on a known scalar passes no arguments to its branch, so only then is the + // branch's own type the result type. + val scalar = e.ty.exists(t => t == DefaultUni.Bool || t == DefaultUni.Integer) + Expr.Match(e, bs, if Semantics.caseOnBuiltins && scalar then Ty.join(bs) else None) + case _ => + val (head, links) = spine(n, Nil) + application(head, links, scope) + + /** Peels `Apply`/`Force` off a spine. Returns the head and the links in evaluation order. */ + @tailrec + private def spine(n: Int, acc: List[Link]): (Int, List[Link]) = nodes(n) match + case _: Term.Apply => spine(n + 1, Link.Arg(children(n)(1)) :: acc) + case _: Term.Force => spine(n + 1, Link.Frc :: acc) + case _ => (n, acc) + + /** The parameters of the lambda chain at `n` (capped at `MaxChain`) and its body. */ + private def chain(n: Int): (List[String], Int) = + @tailrec + def go(m: Int, names: List[String]): (List[String], Int) = nodes(m) match + case Term.LamAbs(name, _, _) if names.size < Typer.MaxChain => go(m + 1, name :: names) + case _ => (names.reverse, m) + go(n, Nil) + + /** A lambda chain. When `recursive`, its first parameter is known to hold the chain itself. */ + private def lambda(n: Int, scope: Vector[Binder], recursive: Boolean): Step[Expr] = + val (params, body) = chain(n) + val first = if recursive then Binder(None, Known.Lambda(n, params.size)) else Param + expr(body, scope ++ (first +: Vector.fill(params.size - 1)(Param))) + .map(Expr.Lambda(n, params, _)) + + /** Every occurrence of variable `i` in `t` applies it to itself — `[i i …]`, or + * `case (constr 0 [i …]) [i]` — so the closure it names never escapes anywhere else. + */ + private def selfApplied(t: Term, i: Int): Boolean = + @tailrec + def go(todo: List[(Term, Int)]): Boolean = todo match + case Nil => true + case (t, i) :: rest => + t match + case Term.Apply(Term.Var(f, _), Term.Var(a, _), _) if f.index == i && a.index == i => + go(rest) + case Term.Case(Term.Constr(tag, Term.Var(a, _) :: args, _), List(Term.Var(f, _)), _) + if tag.value == 0 && a.index == i && f.index == i => + go(args.map((_, i)) ::: rest) + case Term.Var(v, _) => if v.index == i then false else go(rest) + case Term.LamAbs(_, b, _) => go((b, i + 1) :: rest) + case other => go(SourceProgram.subterms(other).map((_, i)) ::: rest) + go(List((t, i))) + + private def application(head: Int, links: List[Link], scope: Vector[Binder]): Step[Expr] = + walk.nested(nodes(head) match + case Term.Builtin(fun, _) => builtinSpine(fun, links, scope) + + case _: Term.LamAbs => + val args = leading(links) + val (params, _) = chain(head) + val bound = math.min(args.size, params.size) + if bound == 0 then expr(head, scope).flatMap(rest(_, links, scope)) + else + // (λx1…λxk. body) a1 … am ⇒ let x1 = a1 … xj = aj in + for + rhss <- all(args.take(bound).zipWithIndex) { (a, j) => + // let x = λself … in … [x x] …: a recursive function, tied by self-application. When + // both x and self are only ever applied to themselves, self always holds the chain. + val recursive = nodes(a).isInstanceOf[Term.LamAbs] && + selfApplied(nodes(head + bound), bound - j) && selfApplied(nodes(a + 1), 1) + if recursive then lambda(a, scope, recursive) else expr(a, scope) + } + inner <- expr(head + bound, scope ++ rhss.map(r => Binder(r.ty, known(r)))) + bindings = params.take(bound).zip(rhss).map(Binding.apply) + let <- rest(Expr.Let(head, bindings, inner, inner.ty), links.drop(bound), scope) + yield let + + // force (delay t) ⇒ t + case _: Term.Delay if links.headOption.contains(Link.Frc) => + val (h, ls) = spine(head + 1, Nil) + application(h, ls ++ links.tail, scope) + + case Term.Var(name, _) => + lookup(scope, name.index).map(_.known) match + case Some(Known.Lambda(origin, arity)) if leading(links).size >= arity => + all(links.take(arity).collect { case Link.Arg(a) => a })(expr(_, scope)).flatMap { + args => + rest( + Expr.CallKnown(Expr.Ref(name.index, None), origin, args), + links.drop(arity), + scope + ) + } + // Builtin values are pure: re-deriving the forced builtin at the call is unobservable. + case Some(Known.Builtin(fun, forces)) if links.nonEmpty => + builtinSpine(fun, List.fill(forces)(Link.Frc) ++ links, scope) + case _ => expr(head, scope).flatMap(rest(_, links, scope)) + + case _ => expr(head, scope).flatMap(rest(_, links, scope))) + + /** The arguments at the front of a spine, before any force. */ + private def leading(links: List[Link]): List[Int] = + links.takeWhile(_.isInstanceOf[Link.Arg]).collect { case Link.Arg(a) => a } + + /** Whether `branch` applied to `fields` arguments evaluated before it is an ordinary application: + * it is a lambda chain, or a known function, taking at least that many. + */ + private def applies(branch: Int, fields: Int, scope: Vector[Binder]): Boolean = + fields == 0 || (nodes(branch) match + case _: Term.LamAbs => chain(branch)._1.size >= fields + case Term.Var(name, _) => + lookup(scope, name.index).exists(_.known match + case Known.Lambda(_, arity) => arity >= fields + case _ => false) + case _ => false) + + private def known(rhs: Expr): Known = + @tailrec + def forced(e: Expr, n: Int): Known = e match + case Expr.Force(inner) => forced(inner, n + 1) + case Expr.BuiltinRef(fun) if Semantics.scheme(fun).numTypeVars >= n => Known.Builtin(fun, n) + case _ => Known.Unknown + rhs match + case Expr.Lambda(origin, params, _) => Known.Lambda(origin, params.size) + case other => forced(other, 0) + + /** Arguments evaluated in order: one that can only fail, after nothing but values, is the whole + * expression — nothing observable runs before it, and nothing after. + */ + private def strict(args: List[Expr])(build: List[Expr] => Expr): Expr = + args.dropWhile(_.isValue).headOption.filter(_.fails).getOrElse(build(args)) + + /** Applies the remaining links dynamically, in order. A function that can only fail is evaluated + * before anything it is applied to, which then never runs. + */ + private def rest(acc: Expr, links: List[Link], scope: Vector[Binder]): Step[Expr] = + links.foldLeft(Done(acc)) { (fn, link) => + fn.flatMap { f => + link match + case _ if f.fails => Done(f) + case Link.Arg(a) => expr(a, scope).map(Expr.Apply(f, _)) + case Link.Frc => Done(Expr.Force(f)) + } + } + + private def builtinSpine(fun: DefaultFun, links: List[Link], scope: Vector[Binder]): Step[Expr] = + val scheme = Semantics.scheme(fun) + val forces = scheme.numTypeVars + val steps = forces + scheme.arity + val prefix = links.take(steps) + // A builtin runs when its last force or argument arrives; with none at all it never would. + val saturated = steps > 0 && prefix.size == steps && prefix.zipWithIndex.forall { + case (Link.Frc, i) => i < forces + case (Link.Arg(_), i) => i >= forces + } + if !saturated then rest(Expr.BuiltinRef(fun), links, scope) + else + val args = prefix.collect { case Link.Arg(a) => a } + val after = links.drop(steps) + val delayed = args.drop(1).filter(nodes(_).isInstanceOf[Term.Delay]) + // force (ifThenElse c (delay a) (delay b)) ⇒ if c then a else b + if selectors(fun) && after.headOption.contains(Link.Frc) && delayed.size == args.size - 1 then + for + scrut <- expr(args.head, scope) + branches <- all(delayed)(d => expr(d + 1, scope)) + choose <- rest(Expr.Choose(fun, scrut, branches, Ty.join(branches)), after.tail, scope) + yield choose + else + all(args)(expr(_, scope)).flatMap { es => + val call = strict(es) { es => + val ty = + if fun == DefaultFun.IfThenElse then Ty.join(es.drop(1)) + else Semantics.result(fun, es.map(_.ty)) + Expr.Call(fun, es, ty) + } + rest(call, after, scope) + } diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/UplcJvm.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/UplcJvm.scala new file mode 100644 index 00000000..e5261386 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/UplcJvm.scala @@ -0,0 +1,69 @@ +package dev.constructive.eo.demo.uplc + +import dev.constructive.eo.optics.{Iso, Prism} +import org.objectweb.asm.tree.ClassNode +import org.objectweb.asm.{ClassReader, ClassTooLargeException, ClassWriter, MethodTooLargeException} + +/** A UPLC → JVM bytecode compiler as eo optics, all starting from the script as the ledger stores + * it: + * + * {{{ + * CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript + * toTyped lowering compiling + * }}} + * + * Every stage keeps the script it came from — a typed program its source, a class the script + * itself, embedded in its constants — so every arrow can be walked back. `lowering` is a lawful + * iso: going there and back is the identity, both ways. The other two are prisms, total on the way + * back. A script may declare a Plutus Core version these semantics do not know + * ([[Semantics.versions]]): then it has no typed program. A class can be too large for a class + * file: then it has none. So the compiler, [[toBytecode]], is a prism too: `toBytecode.getOption` + * compiles, and `toBytecode.reverseGet` hands back the script a class file was compiled from. + */ +object UplcJvm: + + /** Script ⇀ typed expression: decode and type a script of a known Plutus Core version; back, the + * script the program was read from. + */ + val toTyped = Prism[CborScript, TypedProgram]( + script => + val source = SourceProgram.decode(script) + Either.cond(Semantics.versions(source.version), Typer.typeProgram(source), script) + , + _.script, + ) + + /** Typed expression ≅ JVM class: lower; back, type the script the class embeds — of a known + * version, as only a typed program is lowered. + */ + val lowering: Iso[TypedProgram, JvmClass] = + Iso(Lower.lower, cls => Typer.typeProgram(SourceProgram.decode(Lower.script(cls)))) + + /** JVM class ⇀ class file: [[compile]] when the class fits in one; back, [[decompile]]. */ + val compiling = Prism[JvmClass, JvmClassScript](cls => compile(cls).left.map(_ => cls), decompile) + + /** Script ⇀ JVM class. */ + val toJvmClass = toTyped.andThen(lowering) + + /** The compiler, and its inverse on the class files it writes. */ + val toBytecode = toJvmClass.andThen(compiling) + + /** ASM writes the class file, computing its stack map frames — or says why the class does not fit + * in one: the JVM caps a method at 64 KB of bytecode, and a class at 65535 constants. Every + * reference type generated code merges is the same on both paths or `Object`, so no class is + * loaded to find a common one. + */ + def compile(cls: JvmClass): Either[String, JvmClassScript] = + val writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES): + override def getCommonSuperClass(a: String, b: String): String = "java/lang/Object" + // ASM throws when it meets a limit; this is the one place that becomes a value. + try + cls.node.accept(writer) + Right(JvmClassScript(writer.toByteArray)) + catch case e: (MethodTooLargeException | ClassTooLargeException) => Left(e.getMessage) + + /** ASM reads a class file back into its tree; the frames [[compile]] computes are skipped. */ + def decompile(classFile: JvmClassScript): JvmClass = + val tree = new ClassNode + new ClassReader(classFile.bytes).accept(tree, ClassReader.SKIP_FRAMES) + JvmClass(tree) diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Discharge.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Discharge.scala new file mode 100644 index 00000000..6773a93b --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Discharge.scala @@ -0,0 +1,50 @@ +package dev.constructive.eo.demo.uplc.runtime + +import scalus.cardano.ledger.Word64 +import scalus.uplc.{Constant, Term} + +/** Turns a runtime value back into a (de Bruijn) UPLC term — the CEK machine's `dischargeCekValue`, + * so results of the two evaluators can be compared with `α_==`. + * + * A closure becomes its source node with every captured variable replaced by its discharged value. + * The source node comes from the program the class embeds; the capture layout comes from + * [[dev.constructive.eo.demo.uplc.SourceProgram.captures]], the same function the compiler used to + * build the capture array. + */ +object Discharge: + + def apply(value: AnyRef, info: ProgramInfo): Term = value match + case c: Constant => Term.Const(c) + case lazyData @ (_: DataList | _: ConstrPair) => apply(Rt.constant(lazyData), info) + case c: ConstrV => Term.Constr(Word64(c.tag), c.fields.iterator.map(apply(_, info)).toList) + case l: Lam => + // A partially applied chain is its inner lambda, the first `k` parameters bound to the + // values applied so far (innermost = the last one applied); a `delay` is its own node. + val k = l.applied.length + val captures = info.source.captures(l.origin) + substitute( + info.source.nodes(l.origin + k), + j => + if j <= k then Some(apply(l.applied(k - j), info)) + else Some(captures.indexOf(j - k)).filter(_ >= 0).map(i => apply(l.env(i), info)), + ) + case p: Partial => + p.trail.foldLeft[Term](Term.Builtin(p.fun)) { + case (acc, None) => Term.Force(acc) + case (acc, Some(a)) => Term.Apply(acc, apply(a, info)) + } + case other => throw new IllegalStateException(s"not a UPLC value: $other") + + /** Replaces the variables free in `term` that `lookup` resolves; the rest stay (open terms). */ + private def substitute(term: Term, lookup: Int => Option[Term]): Term = + def go(binders: Int, t: Term): Term = t match + case Term.Var(name, _) if name.index > binders => + lookup(name.index - binders).getOrElse(t) + case Term.LamAbs(n, body, a) => Term.LamAbs(n, go(binders + 1, body), a) + case Term.Apply(f, x, a) => Term.Apply(go(binders, f), go(binders, x), a) + case Term.Force(b, a) => Term.Force(go(binders, b), a) + case Term.Delay(b, a) => Term.Delay(go(binders, b), a) + case Term.Constr(tag, args, a) => Term.Constr(tag, args.map(go(binders, _)), a) + case Term.Case(s, cases, a) => Term.Case(go(binders, s), cases.map(go(binders, _)), a) + case other => other + go(0, term) diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/ProgramInfo.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/ProgramInfo.scala new file mode 100644 index 00000000..caa96919 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/ProgramInfo.scala @@ -0,0 +1,20 @@ +package dev.constructive.eo.demo.uplc.runtime + +import dev.constructive.eo.demo.uplc.{CborScript, SourceProgram} +import scalus.uplc.Term + +/** What a generated class knows about its source: the decoded program (to discharge closures) and + * the constant at each `Const` node, by node id. + */ +final class ProgramInfo(val source: SourceProgram): + + def constants(): Array[AnyRef | Null] = + Array.tabulate[AnyRef | Null](source.nodes.length)(i => + source.nodes(i) match { case Term.Const(c, _) => c; case _ => null } + ) + +object ProgramInfo: + + /** Reassembles the script a class stores as string constants (`CborScript.asConstants`). */ + def fromConstants(constants: Array[AnyRef]): ProgramInfo = + new ProgramInfo(SourceProgram.decode(CborScript.fromConstants(constants.map(_.toString)))) diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Rt.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Rt.scala new file mode 100644 index 00000000..94b8177b --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Rt.scala @@ -0,0 +1,212 @@ +package dev.constructive.eo.demo.uplc.runtime + +import scala.annotation.tailrec +import scala.collection.immutable.ArraySeq + +import dev.constructive.eo.demo.uplc.Semantics +import java.util.Arrays +import scalus.cardano.onchain.plutus.prelude.List as PList +import scalus.uplc.builtin.{ByteString, Data} +import scalus.uplc.eval.{CekValue, Logger, MachineError, NoLogger} +import scalus.uplc.{Constant, DefaultFun, DefaultUni, Term, TypeScheme} + +/** The static entry points generated code calls (`Rt.…`). + * + * An evaluation fails by throwing: a `MachineError` from here, whatever Scalus' builtins throw, a + * `ClassCastException` where an ill-typed program meets a cast. It is the JVM's zero-cost way out + * of every frame at once: a result that could be a failure would need a check after every call. + * `Exec.run` is the one place it is caught and becomes a value — any exception escaping an + * evaluation is its failure, as on the CEK machine. A compiler bug throws an `AssertionError`, + * which is not. + */ +object Rt: + + /** The trace log of the evaluation running on the current thread. */ + val logs: ThreadLocal[Logger] = ThreadLocal.withInitial(() => NoLogger) + + private val Empty: Array[AnyRef] = Array.empty + private val True: AnyRef = Constant.Bool(true) + private val False: AnyRef = Constant.Bool(false) + + /** Stackless: the trace would cost more than evaluating a validator (~1.3 µs), and the failure is + * an outcome of the program, not a fault of the JVM code. + */ + def fail(reason: String): Throwable = new MachineError(reason): + override def fillInStackTrace(): Throwable = this + + def noCaptures(): Array[AnyRef] = Empty + + // ---- representations: `box` and `un` for each unboxed `Rep` ------------------------ + + def boxInt(v: BigInt): AnyRef = Constant.Integer(v) + def boxBool(b: Boolean): AnyRef = if b then True else False + def boxBytes(b: ByteString): AnyRef = Constant.ByteString(b) + def boxStr(s: String): AnyRef = Constant.String(s) + def boxData(d: Data): AnyRef = Constant.Data(d) + def unInt(v: AnyRef): BigInt = v.asInstanceOf[Constant.Integer].value + def unBool(v: AnyRef): Boolean = v.asInstanceOf[Constant.Bool].value + def unBytes(v: AnyRef): ByteString = v.asInstanceOf[Constant.ByteString].value + def unStr(v: AnyRef): String = v.asInstanceOf[Constant.String].value + def unData(v: AnyRef): Data = v.asInstanceOf[Constant.Data].value + + // ---- list and pair builtins: the CEK meanings, unwrapped, and lazy over `Data` ----------------- + + def headList(l: AnyRef): AnyRef = l match + case DataList(PList.Cons(head, _)) => Constant.Data(head) + case _ => l.asInstanceOf[Constant.List].value.head + + def tailList(l: AnyRef): AnyRef = l match + case DataList(PList.Cons(_, tail)) => DataList(tail) + case c: Constant.List => c.copy(value = c.value.tail) + + def nullList(l: AnyRef): Boolean = l match + case DataList(elems) => elems.isEmpty + case _ => l.asInstanceOf[Constant.List].value.isEmpty + + def dropList(n: BigInt, l: AnyRef): AnyRef = l match + case DataList(elems) => DataList(elems.drop(n)) + case c: Constant.List => c.copy(value = c.value.drop(n.max(0).min(Int.MaxValue).toInt)) + + def fstPair(p: AnyRef): AnyRef = p match + case ConstrPair(tag, _) => Constant.Integer(tag) + case _ => p.asInstanceOf[Constant.Pair].a + + def sndPair(p: AnyRef): AnyRef = p match + case ConstrPair(_, fields) => DataList(fields) + case _ => p.asInstanceOf[Constant.Pair].b + + def unConstrData(d: Data): AnyRef = + val c = d.asInstanceOf[Data.Constr] + ConstrPair(c.constr, c.args) + + def unListData(d: Data): AnyRef = DataList(d.asInstanceOf[Data.List].values) + + /** A runtime value as the Scalus constant it stands for. */ + def constant(v: AnyRef): AnyRef = v match + case DataList(elems) => Constant.List(DefaultUni.Data, elems.toScalaList.map(Constant.Data(_))) + case ConstrPair(tag, args) => + Constant.Pair(Constant.Integer(tag), constant(DataList(args)).asInstanceOf[Constant]) + case other => other + + // ---- closures ---------------------------------------------------------------------------------- + + /** A lambda chain of `arity` parameters, or a `delay` when there are none. */ + def closure(code: Dispatch, id: Int, origin: Int, arity: Int, env: Array[AnyRef]): AnyRef = + new Lam(code, id, origin, arity, env, Empty) + + /** The environment of a `let`-bound closure, for a direct call of its body method. */ + def envOf(closure: AnyRef): Array[AnyRef] = closure.asInstanceOf[Lam].env + + def apply(f: AnyRef, a: AnyRef): AnyRef = f match + case l: Lam if l.arity == 1 => l.code.call1(l.id, l.env, a) + case _ => applyAll(f, Array(a)) + + private def enter(l: Lam, args: Array[AnyRef]): AnyRef = l.arity match + case 1 => l.code.call1(l.id, l.env, args(0)) + case 2 => l.code.call2(l.id, l.env, args(0), args(1)) + case _ => l.code.callN(l.id, l.env, args) + + /** `f a1 … an`. A lambda chain takes as many arguments as it still needs in one call — partial + * applications in between would have no observable effect — and the result takes the rest. + */ + def applyAll(f: AnyRef, args: Array[AnyRef]): AnyRef = f match + case l: Lam if l.applied.length == 0 && l.arity == args.length && l.arity > 0 => enter(l, args) + case _ => applyAll(f, args, 0) + + @tailrec + private def applyAll(f: AnyRef, args: Array[AnyRef], from: Int): AnyRef = + if from == args.length then f + else + f match + case l: Lam if l.arity > 0 => + val had = l.applied.length + val take = math.min(l.arity - had, args.length - from) + val all = Arrays.copyOf(l.applied, had + take) + System.arraycopy(args, from, all, had, take) + val next = + if had + take < l.arity then new Lam(l.code, l.id, l.origin, l.arity, l.env, all) + else enter(l, all) + applyAll(next, args, from + take) + case p: Partial => applyAll(feed(p, Some(args(from))), args, from + 1) + case other => throw fail(s"cannot apply ${other.getClass.getSimpleName}") + + def force(v: AnyRef): AnyRef = v match + case t: Lam if t.arity == 0 => t.code.call0(t.id, t.env) + case p: Partial => feed(p, None) + case other => throw fail(s"cannot force ${other.getClass.getSimpleName}") + + // ---- builtins as values, and builtins without a direct implementation -------------------------- + + def builtin(ordinal: Int): AnyRef = + val fun = DefaultFun.fromOrdinal(ordinal) + new Partial(fun, Semantics.scheme(fun), Vector.empty, Vector.empty) + + /** One more force (`None`) or argument (`Some`) for a partial builtin; runs it once saturated. */ + private def feed(p: Partial, step: Option[AnyRef]): AnyRef = + val next = (p.scheme, step) match + case (TypeScheme.All(_, rest), None) => rest + case (TypeScheme.Arrow(_, rest), Some(_)) => rest + case _ => throw fail(s"${p.fun}: a force and an argument in the wrong order") + val args = step.fold(p.args)(p.args :+ _) + if next.numTypeVars + next.arity > 0 then new Partial(p.fun, next, args, p.trail :+ step) + else call(p.fun.ordinal, args.toArray) + + /** A builtin by Scalus' CEK meaning, on CEK values. A value that is not a constant goes in as a + * stand-in of its own: a meaning rejects it as it would the closure it replaces, or — a selector + * — returns it, and it is swapped back. + */ + def call(ordinal: Int, args: Array[AnyRef]): AnyRef = + val in = args + .iterator + .map[CekValue](constant(_) match + case c: Constant => CekValue.VCon(c) + case _ => CekValue.VDelay(Term.Error(), ArraySeq.empty)) + .toVector + Semantics.runtime(DefaultFun.fromOrdinal(ordinal)).f(logs.get, in) match + case CekValue.VCon(c) => c + case other => args(in.indexWhere(_ eq other)) + + /** Which of its `n` delayed branches a selector builtin picks: its CEK meaning, on their indices. + */ + def chooseIndex(ordinal: Int, scrut: AnyRef, n: Int): Int = + unInt(call(ordinal, scrut +: Array.tabulate[AnyRef](n)(i => Constant.Integer(i)))).toInt + + // ---- constructors and case --------------------------------------------------------------------- + + def construct(tag: Long, fields: Array[AnyRef]): AnyRef = new ConstrV(tag, fields) + + private def noBranch(what: String, branches: Int): Throwable = + fail(s"case: no branch for $what among $branches") + + /** The branch a `case` takes — the CEK machine's `FrameCases` rules, including PV11 casing on + * builtin values. + */ + def caseIndex(scrut: AnyRef, n: Int): Int = scrut match + case c: ConstrV => + // An unsigned Word64 tag above Int.MaxValue can index no branch list. + if java.lang.Long.compareUnsigned(c.tag, n.toLong) >= 0 then + throw noBranch(s"constructor ${java.lang.Long.toUnsignedString(c.tag)}", n) + else c.tag.toInt + case _ if !Semantics.caseOnBuiltins => throw fail("case on a builtin value before PV11") + case Constant.Integer(i) => integerCaseIndex(i, n) + case Constant.Bool(b) if n == 1 || n == 2 => + if b && n == 1 then throw noBranch("True", n) else if b then 1 else 0 + case Constant.Unit if n == 1 => 0 + case _: Constant.Pair | _: ConstrPair if n == 1 => 0 + case _: Constant.List | _: DataList if n == 1 || n == 2 => + if !nullList(scrut) then 0 else if n == 2 then 1 else throw noBranch("the empty list", n) + case Constant.Data(Data.Constr(tag, _)) if Semantics.caseOnData && tag >= 0 && tag < n => + tag.toInt + case other => throw fail(s"case on ${other.getClass.getSimpleName} with $n branches") + + /** The values a `case` branch is applied to, in order. */ + def caseFields(scrut: AnyRef): Array[AnyRef] = scrut match + case c: ConstrV => c.fields + case _: Constant.List | _: DataList if !nullList(scrut) => + Array(headList(scrut), tailList(scrut)) + case _: Constant.Pair | _: ConstrPair => Array(fstPair(scrut), sndPair(scrut)) + case Constant.Data(Data.Constr(_, fields)) if Semantics.caseOnData => Array(DataList(fields)) + case _ => Empty + + def integerCaseIndex(i: BigInt, n: Int): Int = + if i >= 0 && i < n then i.toInt else throw noBranch(s"integer $i", n) diff --git a/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Values.scala b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Values.scala new file mode 100644 index 00000000..d7b68df6 --- /dev/null +++ b/demos/uplc-jvm/src/main/scala/dev/constructive/eo/demo/uplc/runtime/Values.scala @@ -0,0 +1,50 @@ +package dev.constructive.eo.demo.uplc.runtime + +import scalus.cardano.onchain.plutus.prelude.List as PList +import scalus.uplc.builtin.Data +import scalus.uplc.{DefaultFun, TypeScheme} + +/** Implemented by every generated class. Closures carry the instance plus a method id; the four + * `call` arities are switches over the class's closure bodies. + */ +trait Dispatch: + def run(): AnyRef + def call0(id: Int, env: Array[AnyRef]): AnyRef + def call1(id: Int, env: Array[AnyRef], a: AnyRef): AnyRef + def call2(id: Int, env: Array[AnyRef], a: AnyRef, b: AnyRef): AnyRef + def callN(id: Int, env: Array[AnyRef], args: Array[AnyRef]): AnyRef + +// Runtime values. A UPLC value is one of: a Scalus `Constant` (boxed scalar or structured +// constant), or one of the classes below. + +/** A lambda chain of `arity` parameters rooted at source node `origin`, with `applied` of them + * already supplied (a partial application of a curried chain is still one object) — or, with no + * parameters, `delay body`. + */ +final class Lam( + val code: Dispatch, + val id: Int, + val origin: Int, + val arity: Int, + val env: Array[AnyRef], + val applied: Array[AnyRef], +) + +/** A builtin that has not yet received all of its forces and arguments. `scheme` is what it still + * expects; `trail` records what it got (innermost last) so it can be discharged. + */ +final class Partial( + val fun: DefaultFun, + val scheme: TypeScheme, + val args: Vector[AnyRef], + val trail: Vector[Option[AnyRef]], +) + +/** `constr tag fields`. */ +final class ConstrV(val tag: Long, val fields: Array[AnyRef]) + +/** A `list data` read straight off a `Data` value: an element becomes a constant only when read. */ +final case class DataList(elems: PList[Data]) + +/** The `pair integer (list data)` `unConstrData` returns, before anyone takes it apart. */ +final case class ConstrPair(tag: BigInt, fields: PList[Data]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/LICENSE.md b/demos/uplc-jvm/src/test/resources/plutus-conformance/LICENSE.md new file mode 100644 index 00000000..f49a4e16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/LICENSE.md @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/NOTICE.md b/demos/uplc-jvm/src/test/resources/plutus-conformance/NOTICE.md new file mode 100644 index 00000000..a0a74865 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/NOTICE.md @@ -0,0 +1,11 @@ +Copyright 2024 Intersect MBO + +Licensed under the Apache License, Version 2.0 (the "License”). +You may not use this file except in compliance with the License. +You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.txt + +Unless required by applicable law or agreed to in writing, +software distributed under the License is distributed on an +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +either express or implied. See the License for the specific +language governing permissions and limitations under the License. \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/SOURCE.md b/demos/uplc-jvm/src/test/resources/plutus-conformance/SOURCE.md new file mode 100644 index 00000000..17022a36 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/SOURCE.md @@ -0,0 +1,8 @@ +# Vendored: Plutus conformance suite (UPLC evaluation cases) + +- Upstream: https://github.com/IntersectMBO/plutus/tree/1.63.0.0/plutus-conformance/test-cases/uplc/evaluation +- Tag: `1.63.0.0`, commit `ac40fae4dea9dcad51b38a9c5c48148655cb13a2` +- Cases: 999 (`*.uplc` programs and their `*.uplc.expected` results; budget files omitted) +- License: Apache-2.0, see `LICENSE.md` and `NOTICE.md` (copied verbatim from upstream) + +Regenerate with `demos/uplc-jvm/scripts/refresh-conformance.sh [tag]`; do not edit by hand. diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc new file mode 100644 index 00000000..6f2b83ec --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc @@ -0,0 +1,2 @@ +(program 1.1.0 (con (array integer) [])) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc.expected new file mode 100644 index 00000000..cfbbccf0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/emptyArray/emptyArray.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con (array integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc new file mode 100644 index 00000000..c7bfa1c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc @@ -0,0 +1,2 @@ +(program 1.1.0 (con (array bool) [5]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-01/illTypedArray-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc new file mode 100644 index 00000000..c51e52e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc @@ -0,0 +1,2 @@ +(program 1.1.0 (con (array bool) [(lam x (lam y x))]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/illTypedArray-02/illTypedArray-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc new file mode 100644 index 00000000..dc818352 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc @@ -0,0 +1 @@ +(program 1.1.0 (con (array bool) [True, False, True])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc.expected new file mode 100644 index 00000000..115b0a8b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/simpleArray/simpleArray.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con (array bool) [True,False,True])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc new file mode 100644 index 00000000..8507a8c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc @@ -0,0 +1 @@ +(program 1.1.0 (con (array unit) [(), (), (), (), ()])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc.expected new file mode 100644 index 00000000..8e27ad2a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/array/unitArray/unitArray.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con (array unit) [(),(),(),(),()])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc new file mode 100644 index 00000000..a3895b1e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc @@ -0,0 +1,4 @@ +-- Missing the 0x prefix. +(program 1.0.0 +(con bls12_381_G1_element c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-01/bad-syntax-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc new file mode 100644 index 00000000..dbecc2ce --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc @@ -0,0 +1,4 @@ +-- This has # instead of 0x. +(program 1.0.0 +(con bls12_381_G1_element #c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-syntax-02/bad-syntax-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc new file mode 100644 index 00000000..0e822fe2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc @@ -0,0 +1,4 @@ +-- A bad encoding: this has the negative bit set, but nothing else. +(program 1.0.0 +(con bls12_381_G1_element 0x400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-01/bad-zero-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc new file mode 100644 index 00000000..233d70b3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc @@ -0,0 +1,4 @@ +-- Almost a correct representation of the zero point, but with the negation bit set. +(program 1.0.0 +(con bls12_381_G1_element 0xe00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-02/bad-zero-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc new file mode 100644 index 00000000..73ddb28c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc @@ -0,0 +1,4 @@ +-- The zero point, but with a random bit set in the body (should all be 0) +(program 1.0.0 +(con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/bad-zero-03/bad-zero-03.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc new file mode 100644 index 00000000..00bd2ab3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc @@ -0,0 +1,4 @@ +-- This encodes a field element which isn't the x-coordinate of any point on the curve (no square root). +(program 1.0.0 +(con bls12_381_G1_element 0xa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc new file mode 100644 index 00000000..62cd1dac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc @@ -0,0 +1,4 @@ +-- This is a valid encoding with the sign bit clear. +(program 1.0.0 +(con bls12_381_G1_element 0x81e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected new file mode 100644 index 00000000..b12fff50 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x81e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc new file mode 100644 index 00000000..914cfc09 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc @@ -0,0 +1,4 @@ +-- This is a valid encoding with the sign bit set (obtained by hashing 0x0102030405 to G1) +(program 1.0.0 +(con bls12_381_G1_element 0xa1e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc.expected new file mode 100644 index 00000000..61217201 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-bit3-set/on-curve-bit3-set.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xa1e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc new file mode 100644 index 00000000..1644e3d5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc @@ -0,0 +1,5 @@ +-- This is a valid serialisation of a point on G1 (obtained by hashing 0x0102030405), +-- but we only accept compressed points. +(program 1.0.0 +(con bls12_381_G1_element 0x01e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb12ae8470d881eb628dfcf4bb083fb8a6968d907a0c265f6d06e04b05a19418d395d3e0c115430f88e7156822904ef5bf) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..f857563a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc @@ -0,0 +1,4 @@ +-- This is a valid point on the E1 curve, but it's not in the G1 subgroup. +(program 1.0.0 +(con bls12_381_G1_element 0xa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc new file mode 100644 index 00000000..9dd7812c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc @@ -0,0 +1,4 @@ +-- The compressed encoding of the zero element of G1, but with an extra zero byte at the end. +(program 1.0.0 +(con bls12_381_G1_element 0xc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-long/too-long.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc new file mode 100644 index 00000000..c8ef5794 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc @@ -0,0 +1,4 @@ +-- The zero element of G1, but one byte short +(program 1.0.0 +(con bls12_381_G1_element 0xc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/too-short/too-short.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc new file mode 100644 index 00000000..96b6013b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc @@ -0,0 +1,4 @@ +-- A correct compressed encoding of the zero element of G1. +(program 1.0.0 +(con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc.expected new file mode 100644 index 00000000..2ea2f53f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G1/zero/zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc new file mode 100644 index 00000000..aa8c0ad8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc @@ -0,0 +1,4 @@ +-- Missing the 0x prefix. +(program 1.0.0 +(con bls12_381_G2_element c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-01/bad-syntax-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc new file mode 100644 index 00000000..39077459 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc @@ -0,0 +1,4 @@ +-- This has # instead of 0x. +(program 1.0.0 +(con bls12_381_G2_element #c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-syntax-02/bad-syntax-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc new file mode 100644 index 00000000..e3b4beb3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc @@ -0,0 +1,4 @@ +-- A bad encoding: this has the negative bit set, but nothing else. +(program 1.0.0 +(con bls12_381_G2_element 0x400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-01/bad-zero-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc new file mode 100644 index 00000000..b4c6c3e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc @@ -0,0 +1,4 @@ +-- Almost a correct represntation of the zero point, but with the negation bit set. +(program 1.0.0 +(con bls12_381_G2_element 0xe00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-02/bad-zero-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc new file mode 100644 index 00000000..dcbf8939 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc @@ -0,0 +1,4 @@ +-- The zero point, but with a random bit set in the body (should all be 0) +(program 1.0.0 +(con bls12_381_G2_element 0xc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/bad-zero-03/bad-zero-03.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc new file mode 100644 index 00000000..a78eda2e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc @@ -0,0 +1,4 @@ +-- This encodes a field element which isn't the x-coordinate of any point on the curve (no square root). +(program 1.0.0 +(con bls12_381_G2_element 0xa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc new file mode 100644 index 00000000..e53ae3b6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc @@ -0,0 +1,4 @@ +-- This is a valid encoding with the sign bit clear. +(program 1.0.0 +(con bls12_381_G2_element 0x88138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected new file mode 100644 index 00000000..b6d66a53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x88138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc new file mode 100644 index 00000000..d008a58f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc @@ -0,0 +1,4 @@ +-- This is a valid encoding with the sign bit set (obtained by hashing 0x0102030405 to G2) +(program 1.0.0 +(con bls12_381_G2_element 0xa8138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc.expected new file mode 100644 index 00000000..578eddbd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-bit3-set/on-curve-bit3-set.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xa8138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc new file mode 100644 index 00000000..5a2f8904 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc @@ -0,0 +1,5 @@ +-- This is a valid serialisation of a point on G2 (obtained by hashing 0x0102030405), +-- but we only accept compressed points. +(program 1.0.0 +(con bls12_381_G2_element 0x08138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d071676b275e27060b26dd91aac0a1feb56d1c1de7c323f486e48d54eae0c3c8f4caa45faad589c5d180ac0830dcdb3ecd8126c9c5db86cdf7129cf18582013d267a7c2827a901ef61ab58e7ef150219441abc57671eb39009f6bb166bcbade700d) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..0d810672 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc @@ -0,0 +1,4 @@ +-- This is a valid point on the E2 curve, but it's not in the G2 subgroup. +(program 1.0.0 +(con bls12_381_G2_element 0xa00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc new file mode 100644 index 00000000..242e5c67 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc @@ -0,0 +1,4 @@ +-- The compressed encoding of the zero element of G2, but with an extra zero byte at the end. +(program 1.0.0 +(con bls12_381_G2_element 0xc0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-long/too-long.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc new file mode 100644 index 00000000..40683cde --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc @@ -0,0 +1,4 @@ +-- The zero element of G2, but one byte short +(program 1.0.0 +(con bls12_381_G2_element 0xc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/too-short/too-short.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc new file mode 100644 index 00000000..dfae6e89 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc @@ -0,0 +1,4 @@ +-- A correct compressed encoding of the zero element of G2 +(program 1.0.0 +(con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc.expected new file mode 100644 index 00000000..145261a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bls12-381/G2/zero/zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/False/False.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc new file mode 100644 index 00000000..5591060c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc @@ -0,0 +1,2 @@ +-- Should be either "True" or "False" +(program 1.0.0 (con bool Maybe)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/Maybe/Maybe.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/True/True.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc new file mode 100644 index 00000000..846e5979 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc @@ -0,0 +1,2 @@ +-- Should be "bool", not "boolean" +(program 1.0.0 (con boolean True)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/boolean/boolean.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc new file mode 100644 index 00000000..9518c4f8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc @@ -0,0 +1,2 @@ +-- Should be "False", not "false" +(program 1.0.0 (con bool false)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/false-lc/false-lc.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc new file mode 100644 index 00000000..40aa006a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc @@ -0,0 +1,2 @@ +-- Should be "True", not "true" +(program 1.0.0 (con bool true)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bool/true-lc/true-lc.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc new file mode 100644 index 00000000..3b05f166 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc.expected new file mode 100644 index 00000000..3b05f166 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-01/bytestring-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc new file mode 100644 index 00000000..f019b38d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con bytestring #54686543616B654973414C6965) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc.expected new file mode 100644 index 00000000..fba0ee4a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-02/bytestring-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #54686543616b654973414c6965)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc new file mode 100644 index 00000000..8ecab7fd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con bytestring #) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-03/bytestring-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc new file mode 100644 index 00000000..8644dc3c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con bytestring #12345) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/bytestring/bytestring-04/bytestring-04.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc new file mode 100644 index 00000000..670fff6c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (B #0123456789ABCDEF))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc.expected new file mode 100644 index 00000000..74da7e40 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataByteString/dataByteString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (B #0123456789abcdef))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc new file mode 100644 index 00000000..c0c5f580 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (Constr 1 [I 1]))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc.expected new file mode 100644 index 00000000..9e4963fa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataConstr/dataConstr.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Constr 1 [I 1]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc new file mode 100644 index 00000000..e288bb14 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (I 12354898))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc.expected new file mode 100644 index 00000000..e39458a0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataInteger/dataInteger.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (I 12354898))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc new file mode 100644 index 00000000..a2d1c1d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (List [Constr 1 [], I 1234, B #ABCDEF]))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc.expected new file mode 100644 index 00000000..c616d183 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataList/dataList.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (List [Constr 1 [], I 1234, B #abcdef]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc new file mode 100644 index 00000000..0a55f8ab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 (con data ( + Map [ (B #0123, I 12345), + (I 789453, B #456789), + (List [I -12364689486], Constr 7 []) + ] +))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc.expected new file mode 100644 index 00000000..6b4b56e3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMap/dataMap.uplc.expected @@ -0,0 +1,10 @@ +(program + 1.0.0 + (con + data + (Map + [ (B #0123, I 12345) + , (I 789453, B #456789) + , (List [I -12364689486], Constr 7 []) ]) + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc new file mode 100644 index 00000000..ec148239 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (B 42))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisByteString/dataMisByteString.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc new file mode 100644 index 00000000..a29364d4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (Constr [I 1]))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisConstr/dataMisConstr.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc new file mode 100644 index 00000000..f277c8a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (I []))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisInteger/dataMisInteger.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc new file mode 100644 index 00000000..bde7e458 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con data (List #ABCDEF))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisList/dataMisList.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc new file mode 100644 index 00000000..b23b8da4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 (con data ( + List [ (B #0123, I 12345), + (B #456789, I 789453), + (B #0ABCDE, I 12364689486)] +))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/data/dataMisMap/dataMisMap.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-01/integer-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-02/integer-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-03/integer-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc new file mode 100644 index 00000000..baa8a7d6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer 000000000000000000000000000000000000012345)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc.expected new file mode 100644 index 00000000..d398389d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-04/integer-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 12345)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc new file mode 100644 index 00000000..f0073414 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer -000000000000000000000000000000000000012345)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc.expected new file mode 100644 index 00000000..802f60a5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-05/integer-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -12345)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc new file mode 100644 index 00000000..a7b7d2cb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer 7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc.expected new file mode 100644 index 00000000..c2e85936 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-06/integer-06.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc new file mode 100644 index 00000000..12e9f2de --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer -7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc.expected new file mode 100644 index 00000000..7692ede7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-07/integer-07.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + -7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc new file mode 100644 index 00000000..4a350872 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer +7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc.expected new file mode 100644 index 00000000..c2e85936 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-08/integer-08.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 7934472584735297345829374203940389857324250374130461237461374324689198237413246172439813568362847918324132461234689173469172364972574327894626348923469234728574196241238723984567805163407561370166661807515263473485635726 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc new file mode 100644 index 00000000..1d88041e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0.5)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer-09/integer-09.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc new file mode 100644 index 00000000..82fdc52e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con integer #12)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/integer/integer10/integer10.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc new file mode 100644 index 00000000..d5903a81 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/emptyList/emptyList.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc new file mode 100644 index 00000000..ccab4b6c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc @@ -0,0 +1,2 @@ +(program 1.0.0 (con (list bool) [5]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-01/illTypedList-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc new file mode 100644 index 00000000..8a0195a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc @@ -0,0 +1,2 @@ +(program 1.0.0 (con (list bool) [(lam x (lam y x))]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/illTypedList-02/illTypedList-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc new file mode 100644 index 00000000..622b3c3e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con list(bool) [True, False, True])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/simpleList/simpleList.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc new file mode 100644 index 00000000..2d1c2743 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con list(unit) [(), (), (), (), ()])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/list/unitList/unitList.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc new file mode 100644 index 00000000..c21bfe1b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer (pair bool unit)) (12345, ((),True)))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedNestedPair/illTypedNestedPair.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc new file mode 100644 index 00000000..63ffbd4b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer string) ((lam x x), 1)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-01/illTypedPair-01.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc new file mode 100644 index 00000000..e3ed620e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer string) (1, (lam y y)))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/illTypedPair-02/illTypedPair-02.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc new file mode 100644 index 00000000..5c64ef15 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer (pair unit bool)) (12345, ((),True)))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc.expected new file mode 100644 index 00000000..d9295cd1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/nestedPair/nestedPair.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer (pair unit bool)) (12345, ((), True)))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc new file mode 100644 index 00000000..9b3a6e6a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer bool) (12345, True))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc.expected new file mode 100644 index 00000000..bec63fc0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/pair/simplePair/simplePair.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (pair integer bool) (12345, True))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc new file mode 100644 index 00000000..e0d6a782 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "") +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc.expected new file mode 100644 index 00000000..d8299528 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-01/string-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc new file mode 100644 index 00000000..9d965994 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "xyz") +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc.expected new file mode 100644 index 00000000..40502194 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-02/string-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "xyz")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc new file mode 100644 index 00000000..5f3458d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "λ-calculus") +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc.expected new file mode 100644 index 00000000..6d9ed766 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-03/string-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "λ-calculus")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc new file mode 100644 index 00000000..f6d33263 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "\t\"\83\x75\x63\o143e\x73s\o041\o042\n") +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc.expected new file mode 100644 index 00000000..512e544d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-04/string-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "\t\"Success!\"\n")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc new file mode 100644 index 00000000..810556bd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "x ∈ ℝ ⇒ x² ≥ 0; z ∈ ℂ\\ℝ ⇒ z² ∉ {x ∈ ℝ: x ≥ 0}.") +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc.expected new file mode 100644 index 00000000..05c0dd54 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-05/string-05.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + string + "x ∈ ℝ ⇒ x² ≥ 0; z ∈ ℂ\\ℝ ⇒ z² ∉ {x ∈ ℝ: x ≥ 0}." + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc new file mode 100644 index 00000000..e757be6a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string 144) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-06/string-06.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc new file mode 100644 index 00000000..d173ef42 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc @@ -0,0 +1,16 @@ +(program 1.0.0 + (con (list string) + [ "z ∈ ℝ ⇒ x² ≥ 0; z ∈ ℂ" + , "x \8712 \8477 \8658 x\178 \8805 0; z \8712 \8450\\\8477 \8658 z\178 \8713 {x \8712 \8477: x \8805 0}." + , "\\" + , "\"" + , "--- \"\"\"\" \\ \\ \\\\ \\\\\\ \"" + , "\b\n\a\t" + , "\DEL" + , "€" + , " +" + , " " + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc.expected new file mode 100644 index 00000000..c7cbb295 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-07/string-07.uplc.expected @@ -0,0 +1,16 @@ +(program + 1.0.0 + (con + (list string) + [ "z ∈ ℝ ⇒ x² ≥ 0; z ∈ ℂ" + , "x ∈ ℝ ⇒ x² ≥ 0; z ∈ ℂ\\ℝ ⇒ z² ∉ {x ∈ ℝ: x ≥ 0}." + , "\\" + , "\"" + , "--- \"\"\"\" \\ \\ \\\\ \\\\\\ \"" + , "\b\n\a\t" + , "\DEL" + , "€" + , "\n" + , "\t" ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc new file mode 100644 index 00000000..1ff22d99 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con string "----- \\" hello" +)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/string/string-08/string-08.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc new file mode 100644 index 00000000..0442a645 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con unit unit)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-1/unit-fail-1.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc new file mode 100644 index 00000000..b9d16fa7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con unit 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit-fail-2/unit-fail-2.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc new file mode 100644 index 00000000..10b621b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con unit ())) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc.expected new file mode 100644 index 00000000..10b621b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/unit/unit/unit.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con unit ())) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc new file mode 100644 index 00000000..474af417 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + (con value + [ (#, + [ (#, 123) + , (#, 456) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc.expected new file mode 100644 index 00000000..c263ddaf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/duplicate-keys/duplicate-keys.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 579)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc new file mode 100644 index 00000000..4a4c5a0a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con value [ (#, [])])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty-tokens/empty-tokens.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc new file mode 100644 index 00000000..7d7c99a0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/empty/empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc new file mode 100644 index 00000000..bc07130b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con value [("CURRENCY", [("TOKEN", 123)])])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/ill-formed/ill-formed.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc new file mode 100644 index 00000000..e763e725 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + (con value + [ (#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, + [ (#, 123) + , (#, 456) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-1/key-too-long-1.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc new file mode 100644 index 00000000..b087be8e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + (con value + [ (#, + [ (#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 123) + , (#, 456) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/key-too-long-2/key-too-long-2.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc new file mode 100644 index 00000000..1a9c60e3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + (con value + [ (#, + [ (#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 123) + , (#, 456) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc.expected new file mode 100644 index 00000000..a23e7bfa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-1/max-key-length-1.uplc.expected @@ -0,0 +1,10 @@ +(program + 1.0.0 + (con + value + [ ( # + , [ (#, 456) + , ( #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + , 123 ) ] ) ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc new file mode 100644 index 00000000..7217bdc1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + (con value + [ (#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, + [ (#, 123) + , (#, 456) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc.expected new file mode 100644 index 00000000..36c980ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/max-key-length-2/max-key-length-2.uplc.expected @@ -0,0 +1,8 @@ +(program + 1.0.0 + (con + value + [ ( #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + , [(#, 579)] ) ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc new file mode 100644 index 00000000..baff51ab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc @@ -0,0 +1,15 @@ +(program 1.0.0 + (con value + [ (#, + [ (# , 123) + , (#bb, 50000) + ] + ) + , (#ffff, + [ (#aa, -10) + , (#bb, 20) + ] + ) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc.expected new file mode 100644 index 00000000..ebe530f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/multi/multi.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (con value [(#, [(#, 123), (#bb, 50000)]), (#ffff, [(#aa, -10), (#bb, 20)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc new file mode 100644 index 00000000..9a48f9f3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con value [ (#, [ (# , 170141183460469231731687303715884105727)]) ]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc.expected new file mode 100644 index 00000000..abedd914 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-overflow/no-overflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#, [(#, 170141183460469231731687303715884105727)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc new file mode 100644 index 00000000..44554143 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con value [ (#, [ (# , -170141183460469231731687303715884105728)]) ]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc.expected new file mode 100644 index 00000000..2ae965e9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/no-underflow/no-underflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#, [(#, -170141183460469231731687303715884105728)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc new file mode 100644 index 00000000..c511bdda --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con value [ (#, [ (# , 170141183460469231731687303715884105728)]) ]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/overflow/overflow.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc new file mode 100644 index 00000000..e031b1df --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con value [ (#, [ (# , -170141183460469231731687303715884105729)]) ]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/underflow/underflow.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc new file mode 100644 index 00000000..e7c60f82 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + (con value + [ (#ffff, [ (#bb, 123), (#aa, 456)]) + , (#aa , [ (#aa, 123)]) + , (# , [ (#aa, 123)]) + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc.expected new file mode 100644 index 00000000..49e62a4b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/unordered/unordered.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + value + [(#, [(#aa, 123)]), (#aa, [(#aa, 123)]), (#ffff, [(#aa, 456), (#bb, 123)])] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc new file mode 100644 index 00000000..db0d46e0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 0), (#aa, 1)])])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc.expected new file mode 100644 index 00000000..2152a567 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/constant/value/zero-asset/zero-asset.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#aa, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc new file mode 100644 index 00000000..2ca61006 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc @@ -0,0 +1 @@ +(program 1.0.0 (builtin ifThenElse)) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc.expected new file mode 100644 index 00000000..949db010 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/ite/ite.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (builtin ifThenElse)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc new file mode 100644 index 00000000..71bd3758 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc @@ -0,0 +1,15 @@ +(program + 1.0.0 + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + [ (builtin multiplyInteger) (con integer 11) ] + ] + [ (builtin subtractInteger) (con integer 22) ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc.expected new file mode 100644 index 00000000..fcade660 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied1/iteAtIntegerArrowIntegerApplied1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin multiplyInteger) (con integer 11) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc new file mode 100644 index 00000000..de100aa2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc @@ -0,0 +1,15 @@ +(program + 1.0.0 + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + (builtin multiplyInteger) + ] + (builtin subtractInteger) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc.expected new file mode 100644 index 00000000..481d11b2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerApplied2/iteAtIntegerArrowIntegerApplied2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (builtin multiplyInteger)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc new file mode 100644 index 00000000..7aac3734 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc @@ -0,0 +1,19 @@ +(program + 1.0.0 + [ + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] + (con integer 22) + ] + ] + [ (builtin multiplyInteger) (con integer 11) ] + ] + [ (builtin subtractInteger) (con integer 22) ] + ] + (con integer 22) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc.expected new file mode 100644 index 00000000..d1dce902 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerAppliedApplied/iteAtIntegerArrowIntegerAppliedApplied.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 242)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc new file mode 100644 index 00000000..9e657306 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc @@ -0,0 +1,7 @@ +(program + 1.0.0 + [ + (force (builtin ifThenElse)) + [ [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc.expected new file mode 100644 index 00000000..b3517aef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteAtIntegerArrowIntegerWithCond/iteAtIntegerArrowIntegerWithCond.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 [ (force (builtin ifThenElse)) (con bool True) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc new file mode 100644 index 00000000..6d1f1562 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc @@ -0,0 +1,9 @@ +(program + 1.0.0 + (force + [ + (force (builtin ifThenElse)) + [ [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) ] + ] + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForceAppForce/iteForceAppForce.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc new file mode 100644 index 00000000..76701502 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc @@ -0,0 +1 @@ +(program 1.0.0 (force (builtin ifThenElse))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc.expected new file mode 100644 index 00000000..4612bc65 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForced/iteForced.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (force (builtin ifThenElse))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc new file mode 100644 index 00000000..c67e25cd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc @@ -0,0 +1 @@ +(program 1.0.0 (force (force (builtin ifThenElse)))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedForced/iteForcedForced.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc new file mode 100644 index 00000000..86db2181 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc @@ -0,0 +1,15 @@ +(program + 1.0.0 + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + (con integer 33) + ] + (con string "abc") + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc.expected new file mode 100644 index 00000000..b06788db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteForcedWithIntegerAndString/iteForcedWithIntegerAndString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 33)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc new file mode 100644 index 00000000..d0d331c0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc @@ -0,0 +1,17 @@ +-- This is OK because the branches are terms and there's no requirement that +--their types match in UPLC even if they do happen to be builtin constants. +(program + 1.0.0 + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + (con string "11 <= 22") + ] + (con integer -1111) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc.expected new file mode 100644 index 00000000..5847f262 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringInteger/iteStringInteger.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "11 <= 22")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc new file mode 100644 index 00000000..1c03b179 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc @@ -0,0 +1,15 @@ +(program + 1.0.0 + [ + [ + [ + (force (builtin ifThenElse)) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + (con string "11 <= 22") + ] + (con string "\172(11 <= 22)") + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc.expected new file mode 100644 index 00000000..5847f262 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteStringString/iteStringString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "11 <= 22")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc new file mode 100644 index 00000000..e7d473f1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc @@ -0,0 +1,15 @@ +(program + 1.0.0 + [ + [ + [ + (builtin ifThenElse) + [ + [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) + ] + ] + (con string "11 <= 22") + ] + (con string "\172(11 <= 22)") + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedFullyApplied/iteUnforcedFullyApplied.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc new file mode 100644 index 00000000..c0e48127 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc @@ -0,0 +1,7 @@ +(program + 1.0.0 + [ + (builtin ifThenElse) + [ [ (builtin lessThanEqualsInteger) (con integer 11) ] (con integer 22) ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteUnforcedWithCond/iteUnforcedWithCond.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc new file mode 100644 index 00000000..fd67f901 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc @@ -0,0 +1,10 @@ +(program + 1.0.0 + [ + [ + [ (force (builtin ifThenElse)) (con string "11 <= 22") ] + (con string "\172(11 <= 22)") + ] + (con string "\172(11 <= 22)") + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypeFullyAppied/iteWrongCondTypeFullyAppied.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc new file mode 100644 index 00000000..b356a921 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc @@ -0,0 +1,7 @@ +(program + 1.0.0 + [ + [ (force (builtin ifThenElse)) (con string "11 <= 22") ] + (con string "\172(11 <= 22)") + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc.expected new file mode 100644 index 00000000..f2b5a484 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/iteWrongCondTypePartiallyApplied/iteWrongCondTypePartiallyApplied.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + [ + [ (force (builtin ifThenElse)) (con string "11 <= 22") ] + (con string "\172(11 <= 22)") + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc new file mode 100644 index 00000000..5207ac90 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc @@ -0,0 +1,4 @@ +(program + 1.0.0 + [ [ (force (builtin multiplyInteger)) (con integer 11) ] (con integer 22) ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError1/multiplyIntegerForceError1.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc new file mode 100644 index 00000000..b3efb7d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc @@ -0,0 +1,4 @@ +(program + 1.0.0 + [ (force [ (builtin multiplyInteger) (con integer 11) ]) (con integer 22) ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError2/multiplyIntegerForceError2.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc new file mode 100644 index 00000000..4f2815ba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc @@ -0,0 +1,4 @@ +(program + 1.0.0 + (force [ [ (builtin multiplyInteger) (con integer 11) ] (con integer 22) ]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/interleaving/multiplyIntegerForceError3/multiplyIntegerForceError3.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc new file mode 100644 index 00000000..fb5df464 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin addInteger) (con integer 1)] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-01/addInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc new file mode 100644 index 00000000..7925b9e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin addInteger) (con integer -1789345783478975892347952789342)] (con integer 5734) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc.expected new file mode 100644 index 00000000..1b990d66 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-02/addInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1789345783478975892347952783608)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc new file mode 100644 index 00000000..da8848f6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin addInteger) (con integer -1789345783478975892347952789342)] (con integer 57347348957247358792345278346357234234527384258346526378567285925786235963258) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc.expected new file mode 100644 index 00000000..44365eb8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-03/addInteger-03.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 57347348957247358792345278346357234234527384256557180595088310033438283173916 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc new file mode 100644 index 00000000..01287f77 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin addInteger) (con integer 0)] (con integer 7527934965792342535732746236582734865623578) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc.expected new file mode 100644 index 00000000..22b875f8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-04/addInteger-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 7527934965792342535732746236582734865623578)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc new file mode 100644 index 00000000..09ac9dda --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin addInteger) (con integer 1) (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc.expected new file mode 100644 index 00000000..81805779 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/addInteger/addInteger-uncurried/addInteger-uncurried.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 3)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc new file mode 100644 index 00000000..af50fb8f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool False) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc new file mode 100644 index 00000000..4d7d3f9b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc new file mode 100644 index 00000000..23fd98ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..4624f0c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc new file mode 100644 index 00000000..2e483134 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool False) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..4624f0c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc new file mode 100644 index 00000000..4453d6c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool False) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..757900de --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #44)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc new file mode 100644 index 00000000..98e5be80 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool True) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc new file mode 100644 index 00000000..a16a02aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc new file mode 100644 index 00000000..d31cc087 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc.expected new file mode 100644 index 00000000..4624f0c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc new file mode 100644 index 00000000..431e53c6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool True) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc.expected new file mode 100644 index 00000000..4624f0c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc new file mode 100644 index 00000000..acfccf9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin andByteString) (con bool True) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc.expected new file mode 100644 index 00000000..b7e988e5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #4400)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc new file mode 100644 index 00000000..0bc4529e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin andByteString) + (con bool False) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc.expected new file mode 100644 index 00000000..6605cb6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-11/case-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #13808014808080189900422a0288ac0203640002540830091400164401020021093f210424001cc5508210 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc new file mode 100644 index 00000000..82bc773d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin andByteString) + (con bool True) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc.expected new file mode 100644 index 00000000..ccfd2f9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-12/case-12.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #13808014808080189900422a0288ac0203640002540830091400164401020021093f210424001cc55082101b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc new file mode 100644 index 00000000..e9a61df5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin andByteString) + (con bool False) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc.expected new file mode 100644 index 00000000..6605cb6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-13/case-13.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #13808014808080189900422a0288ac0203640002540830091400164401020021093f210424001cc5508210 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc new file mode 100644 index 00000000..80a3ac10 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin andByteString) + (con bool True) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc.expected new file mode 100644 index 00000000..ccfd2f9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/andByteString/case-14/case-14.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #13808014808080189900422a0288ac0203640002540830091400164401020021093f210424001cc55082101b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc new file mode 100644 index 00000000..ae9df4c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [(builtin appendByteString) (con bytestring #00AABBCC)] (con bytestring #FF0033) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc.expected new file mode 100644 index 00000000..bd3399ab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-01/appendByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00aabbccff0033)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc new file mode 100644 index 00000000..3063eaaa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [(builtin appendByteString) (con bytestring #00AABBCC)] (con bytestring #) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc.expected new file mode 100644 index 00000000..8e5f11c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-02/appendByteString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00aabbcc)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc new file mode 100644 index 00000000..c748e22d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [(builtin appendByteString) (con bytestring #)] (con bytestring #FF0033) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc.expected new file mode 100644 index 00000000..7c6a9985 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendByteString/appendByteString-03/appendByteString-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff0033)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc new file mode 100644 index 00000000..a8de37f1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin appendString) (con string "Ola")] (con string " mundo!") ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc.expected new file mode 100644 index 00000000..dddec3c4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/appendString/appendString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "Ola mundo!")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc new file mode 100644 index 00000000..1e3ee98a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin bData) (con bytestring #0AFD)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc.expected new file mode 100644 index 00000000..c5db1d7c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bData/bData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (B #0afd))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc new file mode 100644 index 00000000..0ffa655f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) for Blake2b_224. +-- Output obtained using the b2sum program from https://github.com/BLAKE2/BLAKE2 +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin blake2b_224) + (con bytestring #) + ] + ] + (con bytestring #836cc68931c2e4e3e838602eca1902591d216837bafddfe6f0c8cb07) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-empty/blake2b_224-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc new file mode 100644 index 00000000..f19e15ae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc @@ -0,0 +1,14 @@ +-- Test vector (200-bit input) for Blake2b_224. +-- Output obtained using the b2sum program from https://github.com/BLAKE2/BLAKE2 +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin blake2b_224) + (con bytestring #2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200) + ] + ] + (con bytestring #93d4b80c531998973b08297fc5042af359865a8702f20b5fc2db8df5) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_224/blake2b_224-length-200/blake2b_224-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc new file mode 100644 index 00000000..7ae43a0f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) for Blake2b_256. +-- Output obtained using the b2sum program from https://github.com/BLAKE2/BLAKE2 +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin blake2b_256) + (con bytestring #) + ] + ] + (con bytestring #0e5751c026e543b2e8ab2eb06099daa1d1e5df47778f7787faab45cdf12fe3a8) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-empty/blake2b_256-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc new file mode 100644 index 00000000..2052b44f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc @@ -0,0 +1,14 @@ +-- Test vector (200-bit input) for Blake2b_256. +-- Output obtained using the b2sum program from https://github.com/BLAKE2/BLAKE2 +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin blake2b_256) + (con bytestring #2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200) + ] + ] + (con bytestring #91c60f99b33303c02b39ed93b713e3915a180c3747f3b31e05727618ee401624) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/blake2b_256/blake2b_256-length-200/blake2b_256-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc new file mode 100644 index 00000000..b1a604fe --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc @@ -0,0 +1,25 @@ +-- Check that adding two random points in G1 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + (builtin bls12_381_G1_add) + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #b93105d0cff4c3f6a42ab790900a26bb1843f4b07fc83d527a66e4a2ddf6c49ea86fe37b1106dbd20dc280ec5996dadf + ) + ] + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #a077246742bfbffdefc1193aba17434d337f231478bf63173065c1e09c34429e76877983ae5f3add1438e5d237f63724 + ) + ] + ] + ] + (con + bls12_381_G1_element + 0x9863eb0a7f8b092fca1a4333866ae3579ad2a4edef84bfcdf736333b3adf0100820c7603b002bf911b564cf032392f07 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/add/add.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc new file mode 100644 index 00000000..df1fe94f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc @@ -0,0 +1,19 @@ +-- Check that negating a random point in G1 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + (builtin bls12_381_G1_neg) + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #b93105d0cff4c3f6a42ab790900a26bb1843f4b07fc83d527a66e4a2ddf6c49ea86fe37b1106dbd20dc280ec5996dadf) + ] + ] + ] + (con + bls12_381_G1_element + 0x993105d0cff4c3f6a42ab790900a26bb1843f4b07fc83d527a66e4a2ddf6c49ea86fe37b1106dbd20dc280ec5996dadf + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/neg/neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc new file mode 100644 index 00000000..c3180379 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc @@ -0,0 +1,23 @@ +-- Scalar multiplication gives the correct result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 29342537169447282925541144552701591957563885683358707334406144036950193508773) + -- 0x40df499974f62e2f268cd5096b0d952073900054122ffce0a27c9d96932891a5 + ] + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #a077246742bfbffdefc1193aba17434d337f231478bf63173065c1e09c34429e76877983ae5f3add1438e5d237f63724) + ] + ] + ] + (con + bls12_381_G1_element + 0xa07796202c3fcad405a5da58d99f0194c8ee21999dd03291f0bfe97e68eb4e69077cf8052b9f5d9cbc4a1394baa0e0d8 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/arith/scalarMul/scalarMul.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc new file mode 100644 index 00000000..450631dd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc @@ -0,0 +1,7 @@ +-- This contains a value which is not the x-coordinate of a point on the E1 curve. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #864cc4f64b12ca99ecdd1962572e6add609d9c619aab678b3fc298bc2f0f81feb4f0d3ebad7e850a8bcb52ca467e649d) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..7f2b1d43 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc @@ -0,0 +1,8 @@ +-- This contains a value which is the x-coordinate of a point which lies on the +-- E1 curve but not the G1 subgroup. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #9483141c933166b61990a706aca07f467d22bc34c6552f5bba91cb1fc21db51d03dfff6523a5e1b4285d54c47660eda1) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G1/uncompress/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc new file mode 100644 index 00000000..f98f8755 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc @@ -0,0 +1,31 @@ +-- Check that adding two random points in G2 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_add) + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b5ed6482bf5486831a9eb445b8b9a77aa6330005b8b432523c69fee7085d3032856de9f857c55ac9745eabcf14894205149cc67393687289e6c2728be69ad1f8ea1a6c0a5a65bf93eca984f3dac5da1abc6f7156ccbc5a33c655f7b17724eb19 + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #a6cc0f01663fd65a95d1359758ebe3a412ce05f4242b0c1f5964351b38e188362a8ceb6c2f86d3f7e5f73b60cd04288005d2a50f8ddf1751d7a915515054276fbae7569c3f18c614c9954177d8e745e98404654cf759d4747b0c806bbd336b7d + ) + ] + ] + ] + (con + bls12_381_G2_element + 0xb3db03681aaf0d218be32f7cc94bd6a975c6870b4a1d4e461b77b60eee2461ca367154b0c4583b2d5f81124aa21fdf3e09ff6b54ce7c57572283a175fba381a32ac6f46abaf11cdbaeb206dcd7d4269caa4d0ebbb3adc1b8fce42ccfa855ea83 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/add/add.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc new file mode 100644 index 00000000..36174007 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc @@ -0,0 +1,20 @@ +-- Check that negating a random point in G2 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + (builtin bls12_381_G2_neg) + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #b5ed6482bf5486831a9eb445b8b9a77aa6330005b8b432523c69fee7085d3032856de9f857c55ac9745eabcf14894205149cc67393687289e6c2728be69ad1f8ea1a6c0a5a65bf93eca984f3dac5da1abc6f7156ccbc5a33c655f7b17724eb19 + ) + ] + ] + ] + (con + bls12_381_G2_element + 0x95ed6482bf5486831a9eb445b8b9a77aa6330005b8b432523c69fee7085d3032856de9f857c55ac9745eabcf14894205149cc67393687289e6c2728be69ad1f8ea1a6c0a5a65bf93eca984f3dac5da1abc6f7156ccbc5a33c655f7b17724eb19 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/neg/neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc new file mode 100644 index 00000000..2027bf78 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc @@ -0,0 +1,24 @@ +-- Scalar multiplication gives the correct result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 29342537169447282925541144552701591957563885683358707334406144036950193508773) + -- 0x40df499974f62e2f268cd5096b0d952073900054122ffce0a27c9d96932891a5 + ] + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #a6cc0f01663fd65a95d1359758ebe3a412ce05f4242b0c1f5964351b38e188362a8ceb6c2f86d3f7e5f73b60cd04288005d2a50f8ddf1751d7a915515054276fbae7569c3f18c614c9954177d8e745e98404654cf759d4747b0c806bbd336b7d + ) + ] + ] + ] + (con + bls12_381_G2_element + 0x89b8e839c317ab3c735c6a65122fff4654f469c30c480701f6e4d9f311f3c5f3411c7cd2876c539bf56f983d14e550b5172765f62bba1235394a33413c21667a57214e9a6f2516f8d7bf57321c20bf8cd8ecd290691ad6bd5ab9e391304240a4 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/arith/scalarMul/scalarMul.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc new file mode 100644 index 00000000..b27711dd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc @@ -0,0 +1,7 @@ +-- This contains a value which is not the x-coordinate of a point on the E2 curve. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #87861839e602fc5dfa0d0b72232dd81d2b0e4b660a7eba353da27e66ceaf2d6c7734925247281866a12d67752a1edaad01ea59e4e86e2e85a81a573cd68f6dfb526558d81a8f488f261f355ddac23f6caf07d27fda71d8f3968d4ceeda89a09d) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..49b6d099 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc @@ -0,0 +1,9 @@ +-- This contains a value which is the x-coordinate of a point which lies on the +-- E2 curve but not the G2 subgroup. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #8bd83699f607412448d202d948bb111badd456d68086ff9a5906ea3b2cda4111d3638391f7a7b153eea77ab47215d6fe13b350f59f884c6e31ac087239d9145b816424cba2c8bcb7b3ed7e19638089d91e5c9136d2aefc8da165284b42229a70 +) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/G2/uncompress/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc new file mode 100644 index 00000000..0c2c2554 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc @@ -0,0 +1,38 @@ +-- <[a]P,Q> = +(program 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #8baa4f3fcd895033f93494b040ccd7dfb77cb759cd2e150bfff4264873174509cd22230423b70896b17c8fc3660f6b21) -- [a]P + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #b67029fbf3ab8e62ab6b499f541537fc07d9466e668392df2bc19762d7dc48b64be09a448cd46dbfe21819a91cd0ab3205f1316ad1cc32853f3f1a1d06497f5cfbc2d753dfc01bff177adeb93f24d452045435dc6eb29f5610b66cd0dd3fb352) -- Q + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #840463aa2f2cda89985b1f3f5eb43b9c29809765d2747d60734b19d6f90610effdfc500af7d458a3e78cee0945ddc669) -- P + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #a80f311db6f2fdc45404870f4c55b65a9a59a35efcfa2a7c595f3955226076bbaa33e403c0d4749495d9423b806f9dbe08cca770e08fa535daefb6dba2edb62f8b9aff6bae83bf48819bcdf98f07e79de8635e8521ddecae19b01a6777bc4684) -- [a]Q + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/balanced/balanced.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc new file mode 100644 index 00000000..2eb9faa4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc @@ -0,0 +1,71 @@ +-- <[a]P,Q><[b]P,Q> = <[a+b]P,Q> +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_mulMlResult) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #8baa4f3fcd895033f93494b040ccd7dfb77cb759cd2e150bfff4264873174509cd22230423b70896b17c8fc3660f6b21 -- [a]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b67029fbf3ab8e62ab6b499f541537fc07d9466e668392df2bc19762d7dc48b64be09a448cd46dbfe21819a91cd0ab3205f1316ad1cc32853f3f1a1d06497f5cfbc2d753dfc01bff177adeb93f24d452045435dc6eb29f5610b66cd0dd3fb352 -- Q + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #a4a925cb9c0580c14cbc8ec54447eb20070336a61c349c6a64b0d87e4db89d77734021cd88e2da369bdd85c0518c66c4 -- [b]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b67029fbf3ab8e62ab6b499f541537fc07d9466e668392df2bc19762d7dc48b64be09a448cd46dbfe21819a91cd0ab3205f1316ad1cc32853f3f1a1d06497f5cfbc2d753dfc01bff177adeb93f24d452045435dc6eb29f5610b66cd0dd3fb352 -- Q + ) + ] + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #aecf54083187026a6b689e70af54375ab7cc6d0d311acb6203730a2904654d6e92f82e62006c0d5e21094155eb93cc98 -- [a+b]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b67029fbf3ab8e62ab6b499f541537fc07d9466e668392df2bc19762d7dc48b64be09a448cd46dbfe21819a91cd0ab3205f1316ad1cc32853f3f1a1d06497f5cfbc2d753dfc01bff177adeb93f24d452045435dc6eb29f5610b66cd0dd3fb352 -- Q + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-additive/left-additive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc new file mode 100644 index 00000000..3f73758d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc @@ -0,0 +1,47 @@ +-- <[a]P,[b]Q> = <[ab]P,Q> +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #8baa4f3fcd895033f93494b040ccd7dfb77cb759cd2e150bfff4264873174509cd22230423b70896b17c8fc3660f6b21 -- [a]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #9906a15ff959b496f478dd17348b32c033236db5a7437768a30c5ce87d9b6adfa7bf2223a0721c93a92f33abac9b2faf00d25e48b0f3cc52595264ef9ad0aa7b81e20b3c8634d577883ff5fc2373a021a1e57826f420a74f3ce0fbd2dcf79415 -- [b]Q + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #b2bb2433441c452b78f5be911aa136dd2c886a9ac329cb6c805e50d5255891fcc389b1190432f16a109c6f431f0f8023 -- [ab]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b67029fbf3ab8e62ab6b499f541537fc07d9466e668392df2bc19762d7dc48b64be09a448cd46dbfe21819a91cd0ab3205f1316ad1cc32853f3f1a1d06497f5cfbc2d753dfc01bff177adeb93f24d452045435dc6eb29f5610b66cd0dd3fb352 -- Q + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/left-multiplicative/left-multiplicative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc new file mode 100644 index 00000000..194f8ee3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc @@ -0,0 +1,71 @@ +-- = +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_mulMlResult) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #840463aa2f2cda89985b1f3f5eb43b9c29809765d2747d60734b19d6f90610effdfc500af7d458a3e78cee0945ddc669 -- P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #a80f311db6f2fdc45404870f4c55b65a9a59a35efcfa2a7c595f3955226076bbaa33e403c0d4749495d9423b806f9dbe08cca770e08fa535daefb6dba2edb62f8b9aff6bae83bf48819bcdf98f07e79de8635e8521ddecae19b01a6777bc4684 -- [a]Q + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #840463aa2f2cda89985b1f3f5eb43b9c29809765d2747d60734b19d6f90610effdfc500af7d458a3e78cee0945ddc669 -- P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #9906a15ff959b496f478dd17348b32c033236db5a7437768a30c5ce87d9b6adfa7bf2223a0721c93a92f33abac9b2faf00d25e48b0f3cc52595264ef9ad0aa7b81e20b3c8634d577883ff5fc2373a021a1e57826f420a74f3ce0fbd2dcf79415 -- [b]Q + ) + ] + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #840463aa2f2cda89985b1f3f5eb43b9c29809765d2747d60734b19d6f90610effdfc500af7d458a3e78cee0945ddc669 -- P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #a63be4a1a776cadc7fc2e2d823bcc905f8f9cb0ebe662360d28d9964b022a99ce34a48b2e93cfceebc9bc1d79a3338da03a41393717239e66d4db06a87510b99fe04b0840c87c4051030b25e56ba34248d9ed30c82e8e501a616097299eefd62 -- [a+b]Q + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-additive/right-additive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc new file mode 100644 index 00000000..7ae52d40 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc @@ -0,0 +1,47 @@ +-- <[a]P,[b]Q> = +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #8baa4f3fcd895033f93494b040ccd7dfb77cb759cd2e150bfff4264873174509cd22230423b70896b17c8fc3660f6b21 -- [a]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #9906a15ff959b496f478dd17348b32c033236db5a7437768a30c5ce87d9b6adfa7bf2223a0721c93a92f33abac9b2faf00d25e48b0f3cc52595264ef9ad0aa7b81e20b3c8634d577883ff5fc2373a021a1e57826f420a74f3ce0fbd2dcf79415 -- [b]Q + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #840463aa2f2cda89985b1f3f5eb43b9c29809765d2747d60734b19d6f90610effdfc500af7d458a3e78cee0945ddc669 -- P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #82606f4c771ca685bfc1bb9c51c886d0daa0f63fbb0f6a24b512a1b9b92d401e556cbffdc204c0a85192c865ed73f8090da58ecd1690d5a3b236cc5d40a98988f9602a6d114edb59954ef4e21692f2d48219aeacb964604849336059ceece69f -- [ab]Q + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/right-multiplicative/right-multiplicative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc new file mode 100644 index 00000000..513c76c2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc @@ -0,0 +1,46 @@ +-- <[a]P,[b]Q> = <[b]P,[a]Q> +(program 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #8baa4f3fcd895033f93494b040ccd7dfb77cb759cd2e150bfff4264873174509cd22230423b70896b17c8fc3660f6b21 -- [a]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #9906a15ff959b496f478dd17348b32c033236db5a7437768a30c5ce87d9b6adfa7bf2223a0721c93a92f33abac9b2faf00d25e48b0f3cc52595264ef9ad0aa7b81e20b3c8634d577883ff5fc2373a021a1e57826f420a74f3ce0fbd2dcf79415 -- [b]Q + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #a4a925cb9c0580c14cbc8ec54447eb20070336a61c349c6a64b0d87e4db89d77734021cd88e2da369bdd85c0518c66c4 -- [b]P + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #a80f311db6f2fdc45404870f4c55b65a9a59a35efcfa2a7c595f3955226076bbaa33e403c0d4749495d9423b806f9dbe08cca770e08fa535daefb6dba2edb62f8b9aff6bae83bf48819bcdf98f07e79de8635e8521ddecae19b01a6777bc4684 -- [a]Q + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/pairing/swap-scalars/swap-scalars.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc new file mode 100644 index 00000000..e2a0816a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc @@ -0,0 +1,62 @@ +-- Check that a signature involving an agumentation string prepended to a message +-- is as expected. +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #83422fd1d8f134fbbc7ad2949a0b7c38dc1f85bfd398bc58ae824ad34ace68eaa49f438872ee22e90778513a91f9685e -- sig + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #93e02b6052719f607dacd3a088274f65596bd0d09920b61ab5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 -- G2 generator + ) + ] + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + [ + [ + (builtin bls12_381_G1_hashToGroup) + [ + [ + (builtin appendByteString) + (con + bytestring + #52616e646f6d2076616c756520666f722074657374206175672e20 -- aug: "Random value for test aug. " + ) + ] + (con bytestring #626c73742069732073756368206120626c617374) -- msg: "blst is such a blast" + + ] + ] + (con + bytestring + #424c535f5349475f424c53313233383147325f584d443a5348412d3235365f535357555f524f5f4e554c5f + -- DST: "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_" + ) + ] + ] + [ + (builtin bls12_381_G2_uncompress) + (con + bytestring + #b756d6223a92609cccf660b6f37e6e34fbb23972fc3955710f9bb202cc84cffacd337792700ebcb4324a99c7e7c9ed6d0e1cfdce8cd879a35300957c69c524c5365f6f0a85130735f27510618bbea605a1d024bb2d3bee2a5d68a827406f11c7 -- pk + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/augmented/augmented.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc new file mode 100644 index 00000000..b678fd54 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc @@ -0,0 +1,35 @@ +-- Check that the procedure for using a DST greater than 255 bytes long gives the expected result. +(program + 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #54657374696e67206c61726765206473742e) -- msg: "Testing large dst." + ] + [ + (builtin sha2_256) + [ + [ + (builtin appendByteString) + (con bytestring #4832432d4f56455253495a452d4453542d) -- prefix: "H2C-OVERSIZE-DST-" + ] + (con + bytestring + #62f5804020e6a8e242c736d1c97bcd8262f91b88e1d70b00d10d5e315c8c6501ead0a7e367e5d394b9fcff9c15aa0f6a05e5085fdc56bcdee3865016f1c49b20e1e609a606eccabc9b9199a42345c25e06ae70028397f8fb95576f264239da3eb49629d5efeb1f1d74a3b1ac58608d893f98058f5ab870833489f5dfec52db5f92e70db05c9704cd9d644b1ae16aaafcc173d48db17e207d91308d3045b042b7241f87b8d42ac5df97d94fdf3f29d20ca2ae22c22e9c5b84b48d6daf1f7959c7c71d0169f370ebf2838479b3731885ff0d278deb632fcb83aef0ab593dddd4f5d21dac56abe08b8cb4aaf4235b1a292b91d6e8b90e39dc953c75fc460e7dd6d2bc8a372ac4efce161f5f18f861e67e5717c86805a05cc53ff493e91de2b85d3166b353f5bbc64bae0d2a4787 -- large_dst: random bytes + ) + ] + ] + ] + ] + [ + (builtin bls12_381_G1_uncompress) + (con + bytestring + #a16b5778b5b88519b6caf05921d0d9b8b94a33d1daaa0c7fbfa66d52e801a5e798fae840bb9608aa31712e0b1b3a054a -- output + ) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381-cardano-crypto-tests/signature/large-dst/large-dst.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc new file mode 100644 index 00000000..656eb7e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc @@ -0,0 +1,33 @@ +-- p+(q+r) = (p+q)+r for three random points on G1. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G1_element 0xb962fd0cc81048e0cf7557bf3e4b6edc5ab4bfb3dc87f83af428b6300727b139c404ab159bdf2eaea3f649903421537f) + ] + ] + ] + [ + (builtin bls12_381_G1_add) + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G1_element 0xb962fd0cc81048e0cf7557bf3e4b6edc5ab4bfb3dc87f83af428b6300727b139c404ab159bdf2eaea3f649903421537f) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-associative/add-associative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc new file mode 100644 index 00000000..54d75b3c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc @@ -0,0 +1,22 @@ +-- p+q = q+p for two random points in G1. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + ] + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-commutative/add-commutative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc new file mode 100644 index 00000000..f2b27774 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc @@ -0,0 +1,10 @@ +-- Adding the zero element to a random point doesn't change it. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc.expected new file mode 100644 index 00000000..67f6485e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add-zero/add-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc new file mode 100644 index 00000000..807a32bf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc @@ -0,0 +1,10 @@ +-- Adding a random pair of points in G1 +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc.expected new file mode 100644 index 00000000..233b768f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_add/add/add.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xa4870e983a149bb1e7cc70fde907a2aa52302833bce4d62f679819022924e9caab52e3631d376d36d9692664b4cfbc22 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc new file mode 100644 index 00000000..90ee2269 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc @@ -0,0 +1,7 @@ +-- Check that compression of a random point in G1 succeeds and gives the expected result. +(program 1.0.0 + [ + (builtin bls12_381_G1_compress) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc.expected new file mode 100644 index 00000000..a7fad2a0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_compress/compress/compress.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc new file mode 100644 index 00000000..c42feadc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-false/equal-false.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc new file mode 100644 index 00000000..c0653b78 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_equal/equal-true/equal-true.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc new file mode 100644 index 00000000..252a7724 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc @@ -0,0 +1,23 @@ +-- Check that hashing different messages with the same DST gives different +-- results: this should return False. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] + ] + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #81) + ] + (con bytestring #0a) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc new file mode 100644 index 00000000..fa4446d6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc @@ -0,0 +1,10 @@ +-- Maximum length of DST is 255 bytes: this should be OK +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #3f) + ] + (con bytestring #123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected new file mode 100644 index 00000000..4108e2b1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x931bd1f65dd2d34a55c93d82c20dcacd3a91afa5932fdd7fed06119f8574520c9609d337d680060b4bd2c59f0b60bb54 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc new file mode 100644 index 00000000..c26a6322 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc @@ -0,0 +1,10 @@ +-- Maximum length of DST is 255 bytes: this should fail +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #3f) + ] + (con bytestring #123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890ff) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc new file mode 100644 index 00000000..be2ec780 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc @@ -0,0 +1,10 @@ +-- Check that hashing a random bytestring with an empty DST gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected new file mode 100644 index 00000000..6f6aa1a8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x9019067bf1fa5b2a7a40fb31a70c66f25a3de7e3ef42f8365c9b7963dc01e15a2e086df6d1a181b1d12811a520440909 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc new file mode 100644 index 00000000..38211b71 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc @@ -0,0 +1,23 @@ +-- Check that hashing the same message with different DSTs gives different +-- results: this should return False. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] + ] + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #01) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc new file mode 100644 index 00000000..2675d562 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc @@ -0,0 +1,10 @@ +-- Check that hashing a random bytestring gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc.expected new file mode 100644 index 00000000..b0e88897 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_hashToGroup/hash/hash.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xa45ddef02cdd86039be4b0a863cba70ea903194ea0489ce619c6276175839d62eea72b095d6566067f4a44b85614f199 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc new file mode 100644 index 00000000..04318944 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc @@ -0,0 +1,13 @@ +-- Multi-scalar multiplication is the same as ordinary scalar multiplication for inputs of size 1. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) [-7843724524521392138901923801823923123123454352157]) + (con (list bls12_381_G1_element) [0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5]) + ] + [(builtin bls12_381_G1_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc new file mode 100644 index 00000000..8fa1e028 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n1*p1+(n2*p2+(n3*p3+(n4*p4+(n5*p5+n6*p6)))) +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 34527457238) + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 78438238) + (con bls12_381_G1_element 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a) + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 123) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc new file mode 100644 index 00000000..6bb7878c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n1*p1+(n2*p2+(n3*p3+(n4*p4+(n5*p5+n6*p6)))) +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 34527457238) + (con bls12_381_G1_element 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7) + (con bls12_381_G1_element 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer 78438238) + (con bls12_381_G1_element 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5) + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 123) + (con bls12_381_G1_element 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d) + ] + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc new file mode 100644 index 00000000..cc2abd2c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = ((((n1*p1+n2*p2)+n3*p3)+n4*p4)+n5*p5)+n6*p6 +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85) + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 34527457238) + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer -7) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 78438238) + (con bls12_381_G1_element 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 123) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc new file mode 100644 index 00000000..aa4300e6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = ((((n1*p1+n2*p2)+n3*p3)+n4*p4)+n5*p5)+n6*p6 +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4) + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 34527457238) + (con bls12_381_G1_element 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer -7) + (con bls12_381_G1_element 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 78438238) + (con bls12_381_G1_element 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5) + ] + ] + [(builtin bls12_381_G1_scalarMul) + (con integer 123) + (con bls12_381_G1_element 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc new file mode 100644 index 00000000..6f45fef1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add, invariant under permutation and association. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n4*p4+((n3*p3+n1*p1)+(n6*p6+(n2*p2+n5*p5))) +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n4*p4 + (con integer -7) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n3*p3 + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4) + ] + [(builtin bls12_381_G1_scalarMul) -- n1*p1 + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85) + ] + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n6*p6 + (con integer 123) + (con bls12_381_G1_element 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n2*p2 + (con integer 34527457238) + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + [(builtin bls12_381_G1_scalarMul) -- n5*p5 + (con integer 78438238) + (con bls12_381_G1_element 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a) + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc new file mode 100644 index 00000000..68c52379 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add, invariant under permutation and association. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n4*p4+((n3*p3+n1*p1)+(n6*p6+(n2*p2+n5*p5))) +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n4*p4 + (con integer -7) + (con bls12_381_G1_element 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n3*p3 + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G1_element 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166) + ] + [(builtin bls12_381_G1_scalarMul) -- n1*p1 + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G1_element 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4) + ] + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n6*p6 + (con integer 123) + (con bls12_381_G1_element 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d) + ] + [(builtin bls12_381_G1_add) + [(builtin bls12_381_G1_scalarMul) -- n2*p2 + (con integer 34527457238) + (con bls12_381_G1_element 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a) + ] + [(builtin bls12_381_G1_scalarMul) -- n5*p5 + (con integer 78438238) + (con bls12_381_G1_element 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5) + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc new file mode 100644 index 00000000..130e09ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc @@ -0,0 +1,49 @@ +-- msm (n:ns) (p:ps) = n*p + msm ns ps +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + [(force (builtin mkCons)) + (con integer -7843724524521392138901923801823923123123454352157) + (con (list integer) + [ 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + ] + [(force (builtin mkCons)) + (con bls12_381_G1_element 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85) + (con (list bls12_381_G1_element) + [ 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc new file mode 100644 index 00000000..30e91c45 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc @@ -0,0 +1,50 @@ +-- msm (n:ns) (p:ps) = n*p + msm ns ps +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + [(force (builtin mkCons)) + (con integer -7843724524521392138901923801823923123123454352157) + (con (list integer) + [ 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + ] + [(force (builtin mkCons)) + (con bls12_381_G1_element 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4) + (con (list bls12_381_G1_element) + [ 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc new file mode 100644 index 00000000..6603d387 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc @@ -0,0 +1,20 @@ +-- First argument is empty list => result = zero +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) [] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc new file mode 100644 index 00000000..50ea456b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc @@ -0,0 +1,21 @@ +-- First argument is empty list => result = zero +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) [] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc new file mode 100644 index 00000000..0dc797f2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc @@ -0,0 +1,18 @@ +-- Second argument is empty list => result = zero +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) []) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc new file mode 100644 index 00000000..0150c9d8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc @@ -0,0 +1,10 @@ +-- Both arguments are empty lists => result = zero +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) []) + (con (list bls12_381_G1_element) []) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc new file mode 100644 index 00000000..e3e6ef48 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc @@ -0,0 +1,52 @@ +-- Extra entries at end of first list are ignored +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc new file mode 100644 index 00000000..57211cbb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc @@ -0,0 +1,53 @@ +-- Extra entries at end of first list are ignored. +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc new file mode 100644 index 00000000..07144b82 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc @@ -0,0 +1,63 @@ +-- Extra entries at end of second list are ignored +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x953902d964d21288d940effdd5c0a9fbb1ea1c315ba1671ed64ae5aaaba1fb4f534818d0185da25b4b18f8aaac3ac8ac + , 0xa03b594a8981e96441eb8b78c44e6d2c74ddef3a2ab29aa1a008079842bc6569d97a6760c7651691a3a7f75305876573 + , 0x94d4cccbce79787e3f62bd467cbba59f55872e924418d57f1b3f095c2c73cf0cb1280c81e8604c5783d3de8885a933a2 + , 0x93a91ee7a7068706b9b7af1c2a2f494d4fdb4dc6d0231abc4504e3adc44668f4281194c4e2ff82716ab2b4a8c7206ff8 + , 0x9570827ff24bcbe2439265bc9524e648c5808793e630386d37a737bdefc6b1f44e6fd75be5b863882f1a23afc9482a53 + , 0x8ab6a042cab84ad5409176005d2de21fd94008de9bc3d24d63bb29b1263cc967400d54e681ec8a17177efd527c5908dc + , 0x82365efc923b4349390d5341a63b8a49eef610d1987e3488eda83405ea65632ba777309effc00cfcd2556a26c80156d7 + , 0x98ecb6abdbdebec853e584e07e33e0047d69874e94524ed677708d464fda0a825e3b239b7105464abaffdfdb92a08097 + , 0x8fd7dc04040fe05723e0d24ecaf5727844c18048fd1226a2c72047048af6d386e697e2230d28970ec51e9fa558d2b021 + , 0x8f8d5b50ebae3b9efdb99b0e528427955838ab1e0382af922352059eea3cd3ec2844d39f740aa7f40bc52b40fd5124f8 + , 0x8a69706450b964997b19bbe0bbd3dd91808cc63f5df9e3513e1bfd5de1d7f10a84a52a1c5b84a9da3182a751d27e3bc5 + , 0x81c87a7282b71c1d70442ec39afe03df9bd839dff07ac6032697b962bc14a654f7835ffa3d4605228edeba208e3492e3 + , 0x8ae3211537182d8655a37b39c6dc6295e47a58b3f8ba58244b4ee270c82889a816fffa1b0361a14faad2353aa3dc1d90 + , 0x969e4efb709fc1ab0296480e77cd689e7757612de75212a87d6e7e4ce2a93539881263235631af26e624589b75c2954b + , 0x8ff80b97b3aec54fee552497506126b57a47f79d6017476337d8d5dac36289a1aa8f2da98580fd8f53eadb4140b71732 + , 0xb35610e600a16f8590ea09a41c44129a4070d03e007927120de989ec1a57fb3a6acdf3a2bd4d2fbd80dd0c6f00f38eac + , 0x818ee62968e5c9ac5948f6a75fdf0a403b0abf47cffce962cc6350c35943c9127674ddfc35efa9898a6866546c554a95 + , 0xaac4ee180e447c630f4137057142c3d7c38ecf83da005fde90834d023969432194c549d4096c40402d9259d6e46e9006 + ] + ) + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc new file mode 100644 index 00000000..44fa2440 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc @@ -0,0 +1,71 @@ +-- Extra entries at end of second list are ignored +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + , 0x8250ad507d9226a172d02a98294a6bb07bc16757a4cef45bc2b83de2f87778cc1ff470337f2781a5e6d4daab1fb47e7f + , 0x97bf126b9bf85e01612a9fc25e5c65a2fbbb040e0f6d953080e243b4ba630a6bf4fb51c8ff2eec24da35d984462b0ae5 + , 0xb0e80d536410cf8b5278cc4044fdb18e12877d1b703c3bb45925dda5714cd24957c3f57bb109c185c5ddc16c8a353ba5 + , 0x98b32a5b91366486dd401d862a89ef61c0b658574784813b882c721504188246ff805b11c4073ffb9bd830cc12315f4c + , 0x98777e52c79054b1b8012dd614679bf9de9d87a9b8173cf8a262e07df62eda3cf4dd67f6836bbb8334e5334be2909f77 + , 0xb591ba12e3e328838105963a9b5f6a964e0e14e096c452768e1de0a1aa69415517615dff9d7815dd56f961c2d79c3baf + , 0xb8012284c8b6ec662a347d522d759a9fee42686101211d14759440469d3ba42b5924954e44581fb374432f1c0d760943 + , 0xb0b6cfc79a85ba80dbc7a6bd5f27dd50d4604869ee4530896b0c6091da4219d155c2d72752f52a31f7286701e7ebdaf3 + , 0xa13c72f1187a4a81987c5a97ae4ff922c79ae5906ac438947e3b20ef005a8c376987a385acd4fa532064c7c49fcc20e7 + , 0x9192ceba2b90309f69c9fb9c50d3dccaea19059818293dc000d52d7657791a83e5d40a705dad2203352cdc786b2015f6 + , 0x97310b39d24a8ed24ef4997158868b92a5c2e66775c544d9fe7392e6b2ea260feb4641f9fb50d91a80273db500abc187 + , 0xb2269c620f74b2c4afb42dd1f7edf61fb4d0d3dd0a26fca989233c151f76c7ce3dbf58f097dfd6d9fc100263af8b5a17 + , 0x8fbcf258661226ad8883273e5213a677d584b5d8e04b3435d4994dce98b98f29b5688e2f5fcb427945b050ac99025607 + , 0xa2bbe64eb10a52992c2efec0d7e8ed50f04d87989c1c0e0474e07ca4144f34f01fc238c8ebb3aba8b1c48f1470f9cd47 + , 0x98838669514a7b3f960da9f45673370e2a90e86e2d4ee78d20be974065db4d735a65fa62b4602c49ccf5ee93fdc7961b + , 0xa5f0ad8a351546578e2e1231a7abdb51fcc583450cf1ef2dea674c6e6d7d163abd8e50f56112f104d858357d666eed12 + , 0xb1d4b98cb712879517d3e74797840f408fe90a4b3e3b74d27689390108896121a243d546ed0888642bcda8cde92a0117 + , 0x80a55cb41aa37175fd8ca54ba9ce6e0da6ad508827ef603756d331370bcdfb03c0b1e9e9d6af279283dd28cdce583bc9 + , 0xb7e66179f2c7459892963e68d5930453f9066f4c75abbc42d6dc3b793bdeebb87f6ebb1746773d6ad442858d3edc3491 + , 0xa7cac65bff12db1b8a17c04e0adcd015999f44c11d0ace183aa32479b7826aa8764cb2b5573f2138c612671d547b1684 + , 0x89e6aa2d08d065032de3e80c2da93747c159aa8534b3c2615d067558bae0f4be547f6abe4530ffcdd9bac7db9abb6009 + , 0x81ce57eee7faadfb0f18fbd9104447381e595a961e4fe26bad19880ea614de09f5111ce4359f0abf464922d9baaf5ffa + , 0xb8e8f444700aad30c8da1dcf16d5496704a950957263e5b4a2272ebb396ed843e00777964925361e0ef5d790db50e39c + , 0x845537bd9dea08fa4515c883baeb1e1972df8c211ef390e4f2357c1e08436eb8f77f0085433adee387c19b6815de38df + , 0x877b6482a469c2af59153f2c785c8bc576c9d5779e118c188d3a8a6a036bd54cf413e172c406bef7cd57be5a3fab3964 + ] + ) + ] + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc new file mode 100644 index 00000000..e4fc048e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc @@ -0,0 +1,47 @@ +-- All entries in second list are the zero point => result is the zero point +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G1_element) + [ 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ] + ) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc new file mode 100644 index 00000000..4c0ea0e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc @@ -0,0 +1,36 @@ +-- All entries in the first list are zero => result is the zero point. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x953902d964d21288d940effdd5c0a9fbb1ea1c315ba1671ed64ae5aaaba1fb4f534818d0185da25b4b18f8aaac3ac8ac + , 0xa03b594a8981e96441eb8b78c44e6d2c74ddef3a2ab29aa1a008079842bc6569d97a6760c7651691a3a7f75305876573 + , 0x94d4cccbce79787e3f62bd467cbba59f55872e924418d57f1b3f095c2c73cf0cb1280c81e8604c5783d3de8885a933a2 + , 0x93a91ee7a7068706b9b7af1c2a2f494d4fdb4dc6d0231abc4504e3adc44668f4281194c4e2ff82716ab2b4a8c7206ff8 + , 0x9570827ff24bcbe2439265bc9524e648c5808793e630386d37a737bdefc6b1f44e6fd75be5b863882f1a23afc9482a53 + , 0x8ab6a042cab84ad5409176005d2de21fd94008de9bc3d24d63bb29b1263cc967400d54e681ec8a17177efd527c5908dc + , 0x82365efc923b4349390d5341a63b8a49eef610d1987e3488eda83405ea65632ba777309effc00cfcd2556a26c80156d7 + , 0x98ecb6abdbdebec853e584e07e33e0047d69874e94524ed677708d464fda0a825e3b239b7105464abaffdfdb92a08097 + , 0x8fd7dc04040fe05723e0d24ecaf5727844c18048fd1226a2c72047048af6d386e697e2230d28970ec51e9fa558d2b021 + , 0x8f8d5b50ebae3b9efdb99b0e528427955838ab1e0382af922352059eea3cd3ec2844d39f740aa7f40bc52b40fd5124f8 + , 0x8a69706450b964997b19bbe0bbd3dd91808cc63f5df9e3513e1bfd5de1d7f10a84a52a1c5b84a9da3182a751d27e3bc5 + , 0x81c87a7282b71c1d70442ec39afe03df9bd839dff07ac6032697b962bc14a654f7835ffa3d4605228edeba208e3492e3 + , 0x8ae3211537182d8655a37b39c6dc6295e47a58b3f8ba58244b4ee270c82889a816fffa1b0361a14faad2353aa3dc1d90 + , 0x969e4efb709fc1ab0296480e77cd689e7757612de75212a87d6e7e4ce2a93539881263235631af26e624589b75c2954b + , 0x8ff80b97b3aec54fee552497506126b57a47f79d6017476337d8d5dac36289a1aa8f2da98580fd8f53eadb4140b71732 + , 0xb35610e600a16f8590ea09a41c44129a4070d03e007927120de989ec1a57fb3a6acdf3a2bd4d2fbd80dd0c6f00f38eac + , 0x818ee62968e5c9ac5948f6a75fdf0a403b0abf47cffce962cc6350c35943c9127674ddfc35efa9898a6866546c554a95 + , 0xaac4ee180e447c630f4137057142c3d7c38ecf83da005fde90834d023969432194c549d4096c40402d9259d6e46e9006 + ] + ) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc new file mode 100644 index 00000000..834d3b2b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc @@ -0,0 +1,44 @@ +-- All entries in the first list are zero => result is the zero point. +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G1_equal) + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) + (con (list bls12_381_G1_element) + [ 0x89a1f2d2c350af95381b09f307e467ef4629aa3acd1c8eb6143d0a07bc072aa6c69635bcb3c83aab43a68e07f024f7b4 + , 0xb9d49de64b4f0743f603e44697bea32d6b8065fa64efc77b435bcd3adea5af55a958e33034fe2cd13c99280f2987537a + , 0x93fd9bd18c19665db678479fb28a7aadce222986e894196bafd85d487d43a4bba22b66891d753f61e075c503b64f4166 + , 0x85613b4871d8b2e0353c135c0b94f50a9966c424f6a8ee9d12c646392a22c51498317a50acd891589b358113acea4e62 + , 0x8056aaf9b83cb4b3355ef95703832a03bcb9a6007bb1264908d4f27bc497aff4cacaed01c3e14c68914fb35327713bc5 + , 0x876d7c92a343dcb531b4c0f6b8f69f68a669deceb2a157f3fc3275133dcd3f663da0750f6edcd7b8fa89a2572c44950d + , 0x8250ad507d9226a172d02a98294a6bb07bc16757a4cef45bc2b83de2f87778cc1ff470337f2781a5e6d4daab1fb47e7f + , 0x97bf126b9bf85e01612a9fc25e5c65a2fbbb040e0f6d953080e243b4ba630a6bf4fb51c8ff2eec24da35d984462b0ae5 + , 0xb0e80d536410cf8b5278cc4044fdb18e12877d1b703c3bb45925dda5714cd24957c3f57bb109c185c5ddc16c8a353ba5 + , 0x98b32a5b91366486dd401d862a89ef61c0b658574784813b882c721504188246ff805b11c4073ffb9bd830cc12315f4c + , 0x98777e52c79054b1b8012dd614679bf9de9d87a9b8173cf8a262e07df62eda3cf4dd67f6836bbb8334e5334be2909f77 + , 0xb591ba12e3e328838105963a9b5f6a964e0e14e096c452768e1de0a1aa69415517615dff9d7815dd56f961c2d79c3baf + , 0xb8012284c8b6ec662a347d522d759a9fee42686101211d14759440469d3ba42b5924954e44581fb374432f1c0d760943 + , 0xb0b6cfc79a85ba80dbc7a6bd5f27dd50d4604869ee4530896b0c6091da4219d155c2d72752f52a31f7286701e7ebdaf3 + , 0xa13c72f1187a4a81987c5a97ae4ff922c79ae5906ac438947e3b20ef005a8c376987a385acd4fa532064c7c49fcc20e7 + , 0x9192ceba2b90309f69c9fb9c50d3dccaea19059818293dc000d52d7657791a83e5d40a705dad2203352cdc786b2015f6 + , 0x97310b39d24a8ed24ef4997158868b92a5c2e66775c544d9fe7392e6b2ea260feb4641f9fb50d91a80273db500abc187 + , 0xb2269c620f74b2c4afb42dd1f7edf61fb4d0d3dd0a26fca989233c151f76c7ce3dbf58f097dfd6d9fc100263af8b5a17 + , 0x8fbcf258661226ad8883273e5213a677d584b5d8e04b3435d4994dce98b98f29b5688e2f5fcb427945b050ac99025607 + , 0xa2bbe64eb10a52992c2efec0d7e8ed50f04d87989c1c0e0474e07ca4144f34f01fc238c8ebb3aba8b1c48f1470f9cd47 + , 0x98838669514a7b3f960da9f45673370e2a90e86e2d4ee78d20be974065db4d735a65fa62b4602c49ccf5ee93fdc7961b + , 0xa5f0ad8a351546578e2e1231a7abdb51fcc583450cf1ef2dea674c6e6d7d163abd8e50f56112f104d858357d666eed12 + , 0xb1d4b98cb712879517d3e74797840f408fe90a4b3e3b74d27689390108896121a243d546ed0888642bcda8cde92a0117 + , 0x80a55cb41aa37175fd8ca54ba9ce6e0da6ad508827ef603756d331370bcdfb03c0b1e9e9d6af279283dd28cdce583bc9 + , 0xb7e66179f2c7459892963e68d5930453f9066f4c75abbc42d6dc3b793bdeebb87f6ebb1746773d6ad442858d3edc3491 + , 0xa7cac65bff12db1b8a17c04e0adcd015999f44c11d0ace183aa32479b7826aa8764cb2b5573f2138c612671d547b1684 + , 0x89e6aa2d08d065032de3e80c2da93747c159aa8534b3c2615d067558bae0f4be547f6abe4530ffcdd9bac7db9abb6009 + , 0x81ce57eee7faadfb0f18fbd9104447381e595a961e4fe26bad19880ea614de09f5111ce4359f0abf464922d9baaf5ffa + , 0xb8e8f444700aad30c8da1dcf16d5496704a950957263e5b4a2272ebb396ed843e00777964925361e0ef5d790db50e39c + , 0x845537bd9dea08fa4515c883baeb1e1972df8c211ef390e4f2357c1e08436eb8f77f0085433adee387c19b6815de38df + , 0x877b6482a469c2af59153f2c785c8bc576c9d5779e118c188d3a8a6a036bd54cf413e172c406bef7cd57be5a3fab3964 + ] + ) + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc new file mode 100644 index 00000000..b2d24bf5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc @@ -0,0 +1,23 @@ +-- Maximum allowed scalar is OK +(program 1.0.0 + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095167 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected new file mode 100644 index 00000000..eb50d355 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8e08657a52d6d3b029f078f927065f3261aed25076b3b632a80647b2aa76b4db2b3b1be62ddfe383fb59f8f561ebb94c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc new file mode 100644 index 00000000..c991301c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc @@ -0,0 +1,23 @@ +-- A scalar one greater than the maximum causes an error +(program 1.0.0 + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc new file mode 100644 index 00000000..7169a32f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc @@ -0,0 +1,23 @@ +-- The minimum allowed scalar is OK +(program 1.0.0 + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , -522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected new file mode 100644 index 00000000..9bcc8570 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xaa98bfdb0e78966cc3529435fcc393ed5afac8d43d008dff8bf2f6f77529978d9716e0a03d69ff812c827147d052d4ad + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc new file mode 100644 index 00000000..bb659ddb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc @@ -0,0 +1,23 @@ +-- A scalar one less than the minimum causes an error +(program 1.0.0 + [(builtin bls12_381_G1_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , -522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095169 + , 123 + ] + ) + (con (list bls12_381_G1_element) + [ 0xab5d1d67b495361c3297c721cf3c9dc510fc5055bdf92fefc1e67d91a00a765520150428eb4c2fb01902d41d5ca62d85 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xb1cdc04561c6bd93294fc05a3a27170ffdca767965cdd7f2ba6065d6805e9c3afbb64e68604ddce26401566a74b35fb4 + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + , 0x84a8c4b64514db1bedfab0baa53fbed998672626b4c715652583a504df9c44ad3fe106cb421694cc86b2f2371eacd28a + , 0x8b9120083e12fe72d41e1488078a84a6629c2d90e00c238152b4cba64c20994196a1f4de9132f44597b566c80f17d64a + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc new file mode 100644 index 00000000..92d3c7a9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc @@ -0,0 +1,13 @@ +-- Check that adding a random point to its negative gives the zero element. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + [ + (builtin bls12_381_G1_neg) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc.expected new file mode 100644 index 00000000..2ea2f53f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/add-neg/add-neg.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc new file mode 100644 index 00000000..f66ddeda --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc @@ -0,0 +1,7 @@ +-- The negative of the zero point is the zero point. +(program 1.0.0 + [ + (builtin bls12_381_G1_neg) + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc.expected new file mode 100644 index 00000000..2ea2f53f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg-zero/neg-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc new file mode 100644 index 00000000..7bc37d59 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc @@ -0,0 +1,7 @@ +-- Check that negating a random point in G1 gives the expected result. +(program 1.0.0 + [ + (builtin bls12_381_G1_neg) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc.expected new file mode 100644 index 00000000..c5383961 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_neg/neg/neg.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8bd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc new file mode 100644 index 00000000..0701e6bf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc @@ -0,0 +1,22 @@ +-- 2157p + 2157q for random points p and q in G1. This should give the same result as muladd. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_add) + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 2157) + ] + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + ] + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 2157) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc.expected new file mode 100644 index 00000000..8a8440b5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/addmul/addmul.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8cc84679c6c870408169a656c245a2ab9ccc46598769b19f07711c18624284d1bfa33667cac7b99a12e058abfd14ef88 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc new file mode 100644 index 00000000..968a9153 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc @@ -0,0 +1,10 @@ +-- Check that multiplication by the scalar 44 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 44) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc.expected new file mode 100644 index 00000000..de8b77d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-44/mul-44.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8d9e9f6adcea14e8d38221bb3cfe4afdcc59b86e9d3b0093c0ef8252d5d90dfc5d73c9e9d352b9a54b46d35e7ff4d58c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc new file mode 100644 index 00000000..b15f84a5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc @@ -0,0 +1,10 @@ +-- Check that the result of multiplying by -1 is as expected. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer -1) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc.expected new file mode 100644 index 00000000..c5383961 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-neg-one/mul-neg-one.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8bd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc new file mode 100644 index 00000000..d1718d8e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc @@ -0,0 +1,10 @@ +-- Scalar multiplication by 1 leaves a random point unchanged. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 1) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc.expected new file mode 100644 index 00000000..67f6485e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-one/mul-one.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc new file mode 100644 index 00000000..f4858c59 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc @@ -0,0 +1,10 @@ +-- Multiplication by the zero scalar gives the zero point of G1. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 0) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc.expected new file mode 100644 index 00000000..2ea2f53f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul-zero/mul-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc new file mode 100644 index 00000000..4f179b65 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc @@ -0,0 +1,22 @@ +-- 19p+25p for a random point p in G1. This should give the same result as mul44. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_add) + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 19) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 25) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc.expected new file mode 100644 index 00000000..de8b77d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul19+25/mul19+25.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8d9e9f6adcea14e8d38221bb3cfe4afdcc59b86e9d3b0093c0ef8252d5d90dfc5d73c9e9d352b9a54b46d35e7ff4d58c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc new file mode 100644 index 00000000..8e6057a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc @@ -0,0 +1,16 @@ +-- 4*(11*p) for a point in G1. This should give the same result as mul44. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 4) + ] + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 11) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc.expected new file mode 100644 index 00000000..de8b77d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mul4x-11/mul4x-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8d9e9f6adcea14e8d38221bb3cfe4afdcc59b86e9d3b0093c0ef8252d5d90dfc5d73c9e9d352b9a54b46d35e7ff4d58c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc new file mode 100644 index 00000000..1e28131d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc @@ -0,0 +1,16 @@ +-- n(p+q) = np + nq (n scalar, p and q random points in G1). +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer 2157) + ] + [ + [ + (builtin bls12_381_G1_add) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc.expected new file mode 100644 index 00000000..8a8440b5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/muladd/muladd.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x8cc84679c6c870408169a656c245a2ab9ccc46598769b19f07711c18624284d1bfa33667cac7b99a12e058abfd14ef88 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc new file mode 100644 index 00000000..f9e5a077 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc @@ -0,0 +1,10 @@ +-- Multiplying a random point in G1 by the scalar -44 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_scalarMul) + (con integer -44) + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc.expected new file mode 100644 index 00000000..e96e2fa1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulneg-44/mulneg-44.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xad9e9f6adcea14e8d38221bb3cfe4afdcc59b86e9d3b0093c0ef8252d5d90dfc5d73c9e9d352b9a54b46d35e7ff4d58c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc new file mode 100644 index 00000000..fb4cb554 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc @@ -0,0 +1,13 @@ +-- Scalar multiplication by the group size should give you the zero element of the group. +(program 1.0.0 +[ + [ (builtin bls12_381_G1_equal) + [ + (builtin bls12_381_G1_scalarMul) + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513 ) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] + (con bls12_381_G1_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc new file mode 100644 index 00000000..8b027758 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc @@ -0,0 +1,23 @@ +-- Scalar multiplication should be periodic modulo the group size +(program 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] + [ + [ (builtin bls12_381_G1_scalarMul) (con integer 123) ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc new file mode 100644 index 00000000..8aeb4591 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc @@ -0,0 +1,27 @@ +-- Scalar multiplication should be periodic modulo the group size +(program + 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + [ + [ (builtin multiplyInteger) (con integer 987654321) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] + [ + [ (builtin bls12_381_G1_scalarMul) (con integer 123) ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc new file mode 100644 index 00000000..250e6fa3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc @@ -0,0 +1,27 @@ +-- Scalar multiplication should be periodic modulo the group size +(program + 1.0.0 + [ + [ + (builtin bls12_381_G1_equal) + [ + [ + (builtin bls12_381_G1_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + [ + [ (builtin multiplyInteger) (con integer -987654321) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] + [ + [ (builtin bls12_381_G1_scalarMul) (con integer 123) ] + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc new file mode 100644 index 00000000..2f887518 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc @@ -0,0 +1,7 @@ +-- This has the infinity bit set but not the compression bit, and so is invalid. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-01/bad-zero-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc new file mode 100644 index 00000000..19e4806c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc @@ -0,0 +1,7 @@ +-- This is the zero point of G1, but with the sign bit set. It should fail to uncompress. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-02/bad-zero-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc new file mode 100644 index 00000000..0471d18a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc @@ -0,0 +1,8 @@ +-- This is the zero point of G1, but with a random bit set in the body. It +-- should fail to uncompress. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #c00000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/bad-zero-03/bad-zero-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc new file mode 100644 index 00000000..d491b06b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc @@ -0,0 +1,7 @@ +-- This contains a value which is not the x-coordinate of a point on the E1 curve. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc new file mode 100644 index 00000000..2fd7125d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc @@ -0,0 +1,8 @@ +-- This value was obtained by hashing 0x0102030405 to G1 but has had the +-- compression bit cleared, so uncompression should fail. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #21e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc new file mode 100644 index 00000000..ef082c2f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc @@ -0,0 +1,9 @@ +-- This value was obtained by hashing 0x0102030405 to G1. The sign bit was set +-- but has been cleared: this negates the point, so uncompression should still +-- succeed. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #81e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected new file mode 100644 index 00000000..b12fff50 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0x81e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc new file mode 100644 index 00000000..8cb0cfa5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc @@ -0,0 +1,8 @@ +-- This value was obtained by hashing 0x0102030405 to G1. No changes have been +-- made, so uncompression should succeed. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #a1e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected new file mode 100644 index 00000000..61217201 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xa1e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc new file mode 100644 index 00000000..71f6080c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc @@ -0,0 +1,10 @@ +-- This checks that the uncompression function fails on a valid *serialised* G1 +-- point (obtained by hashing 0x0102030405 onto G1). The deserialisation +-- function in the blst library can handle both serialised and compressed +-- points, but we should fail on the former. +(program 1.0.0 + [ (builtin bls12_381_G1_uncompress) + (con bytestring + #01e9a0c68985059bd25a5ef05b351ca22f7d7c19e37928583ae12a1f4939440ff754cfd85b23df4a54f66c7089db6deb12ae8470d881eb628dfcf4bb083fb8a6968d907a0c265f6d06e04b05a19418d395d3e0c115430f88e7156822904ef5bf) +] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..7369b082 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc @@ -0,0 +1,8 @@ +-- This contains a value which is the x-coordinate of a point which lies on the +-- E1 curve but not the G1 subgroup. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc new file mode 100644 index 00000000..32da7bf6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc @@ -0,0 +1,8 @@ +-- The bytestring is the compressed version of the G1 zero point, but extended +-- to 49 bytes. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-long/too-long.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc new file mode 100644 index 00000000..de4e2a6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc @@ -0,0 +1,7 @@ +-- The bytestring is the compressed version of the G1 zero point, but truncated to 47 bytes. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/too-short/too-short.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc new file mode 100644 index 00000000..875a25e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc @@ -0,0 +1,7 @@ +-- The zero element of G1 uncompresses correctly. +(program 1.0.0 + [ + (builtin bls12_381_G1_uncompress) + (con bytestring #c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc.expected new file mode 100644 index 00000000..2ea2f53f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G1_uncompress/zero/zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G1_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc new file mode 100644 index 00000000..a0ee7305 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc @@ -0,0 +1,37 @@ +-- p+(q+r) = (p+q)+r for three random points on G2. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a +) + ] + (con bls12_381_G2_element 0xa69d86e011cf692e51ac2031201c27aa06a8f902068fcb98f284d9d925c6502bb0821ba4f49ece3d1db06cd9556f690a117e51df792f7c1d1f5f22b91c3155e9ef2bc43f24ab0a62d8606b3262a117c5635326ae8c9ad897980db6bf4849f903 +) + ] + ] + ] + [ + (builtin bls12_381_G2_add) + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a +) + ] + (con bls12_381_G2_element 0xa69d86e011cf692e51ac2031201c27aa06a8f902068fcb98f284d9d925c6502bb0821ba4f49ece3d1db06cd9556f690a117e51df792f7c1d1f5f22b91c3155e9ef2bc43f24ab0a62d8606b3262a117c5635326ae8c9ad897980db6bf4849f903 +) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-associative/add-associative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc new file mode 100644 index 00000000..441b8699 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc @@ -0,0 +1,24 @@ +-- p+q = q+p for two random points in G2. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 +) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 +) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-commutative/add-commutative.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc new file mode 100644 index 00000000..18adedbe --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc @@ -0,0 +1,10 @@ +-- Adding the zero element to a random point doesn't change it. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc.expected new file mode 100644 index 00000000..fa158051 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add-zero/add-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc new file mode 100644 index 00000000..7eb51f91 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc @@ -0,0 +1,10 @@ +-- Check that adding two random points on G2 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc.expected new file mode 100644 index 00000000..5cecee55 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_add/add/add.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xb5cf6c76309d98a38950948ce6768309e2e92561762734caaaab65077e1279faff6bba6f9f21bbb3b3fa4ee55aa1332d0f4b3b9a6fa4848e0bf7ae0d38fdc1f1c1908b953ee2b47b88a595b10431acab16522d12a785e27692fc7e0ffa33be07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc new file mode 100644 index 00000000..86a22550 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc @@ -0,0 +1,7 @@ +-- Check that compression of a random point in G2 succeeds and gives the expected result. +(program 1.0.0 + [ + (builtin bls12_381_G2_compress) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc.expected new file mode 100644 index 00000000..0230ddae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_compress/compress/compress.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #b0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc new file mode 100644 index 00000000..6c90ac74 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-false/equal-false.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc new file mode 100644 index 00000000..c4007b4d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc @@ -0,0 +1,10 @@ +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_equal/equal-true/equal-true.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc new file mode 100644 index 00000000..13309207 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc @@ -0,0 +1,23 @@ +-- Check that hashing different messages with the same DST gives different +-- results: this should return False. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] + ] + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #81) + ] + (con bytestring #0a) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-different-msg-same-dst/hash-different-msg-same-dst.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc new file mode 100644 index 00000000..b9ba3819 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc @@ -0,0 +1,10 @@ +-- Maximum length of DST is 255 bytes: this should be OK +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #3f) + ] + (con bytestring #123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected new file mode 100644 index 00000000..adc5ec3b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-255/hash-dst-len-255.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x9028b507444b4283faf2f85e7f7d3890b67e9bcf84c7de2f75fe603996ab1b12a25b4637d68f310b7bd6d47ec11e3fa60d0f8f9d1dc880746105b4d7e9b5bba86abfdef96dfda303b1fb00b5d866b5d7f67883efb39efca301ae44a7f1322a33 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc new file mode 100644 index 00000000..c0178489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc @@ -0,0 +1,10 @@ +-- Maximum length of DST is 255 bytes: this should fail +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #3f) + ] + (con bytestring #123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890ff) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-dst-len-256/hash-dst-len-256.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc new file mode 100644 index 00000000..ab6c5797 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc @@ -0,0 +1,10 @@ +-- Check that hashing a random bytestring with an empty DST gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected new file mode 100644 index 00000000..8201dfc7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-empty-dst/hash-empty-dst.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x8785334bbccf9f7a1bc656fcbcaf9901521cc09a076ff69d40e467082b605d668219747dfec37c798c97b2c7f28ec90117c4ccfc54ef3cc3c0038951c4969a3c0b3fb842a78103586657428ab38d719c9d3314de566cd95540aaccf7afd48821 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc new file mode 100644 index 00000000..cdf59413 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc @@ -0,0 +1,23 @@ +-- Check that hashing the same message with different DSTs gives different +-- results: this should return False. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] + ] + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #01) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash-same-msg-different-dst/hash-same-msg-different-dst.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc new file mode 100644 index 00000000..ec831773 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc @@ -0,0 +1,10 @@ +-- Check that hashing a random bytestring gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_hashToGroup) + (con bytestring #8e) + ] + (con bytestring #0a) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc.expected new file mode 100644 index 00000000..6c0812e6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_hashToGroup/hash/hash.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xabdb064dbaa986d9609796d7a80ef07f719f99fa5d9876e01f9298793d4c7e7ba9b2c55da6896f90693ad76a093d280118a4c24df9a387eaf85b15927365a110fe5256f53ddf8bef4069fe761d8215d4a73ec980f1a801dbaba25146b6ca7e07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc new file mode 100644 index 00000000..5e3eca4e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc @@ -0,0 +1,14 @@ +-- Multi-scalar multiplication is the same as ordinary scalar multiplication for inputs of size 1. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) [-7843724524521392138901923801823923123123454352157]) + (con (list bls12_381_G2_element) [0xae2eee55b1b79df45e4d5530912e0d6631268206308ac456b1ee790be4b3f545cf6a7341c7d81ea8ec587dbde47392c207195fc213a5971aecb26cfa6178eb7c765a48c1fe5baf3da8cd499841754672e6ca5a1e7617cf6aa40fdf6305624127 +]) + ] + [(builtin bls12_381_G2_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xae2eee55b1b79df45e4d5530912e0d6631268206308ac456b1ee790be4b3f545cf6a7341c7d81ea8ec587dbde47392c207195fc213a5971aecb26cfa6178eb7c765a48c1fe5baf3da8cd499841754672e6ca5a1e7617cf6aa40fdf6305624127) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-01/multiScalarMul-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc new file mode 100644 index 00000000..ea8a790c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n1*p1+(n2*p2+(n3*p3+(n4*p4+(n5*p5+n6*p6)))) +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 34527457238) + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7) + (con bls12_381_G2_element 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 78438238) + (con bls12_381_G2_element 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31) + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 123) + (con bls12_381_G2_element 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3) + ] + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02a/multiScalarMul-02a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc new file mode 100644 index 00000000..31f98570 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n1*p1+(n2*p2+(n3*p3+(n4*p4+(n5*p5+n6*p6)))) +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 34527457238) + (con bls12_381_G2_element 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7) + (con bls12_381_G2_element 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer 78438238) + (con bls12_381_G2_element 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f) + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 123) + (con bls12_381_G2_element 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9) + ] + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-02b/multiScalarMul-02b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc new file mode 100644 index 00000000..996551ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = ((((n1*p1+n2*p2)+n3*p3)+n4*p4)+n5*p5)+n6*p6 +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72) + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 34527457238) + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer -7) + (con bls12_381_G2_element 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 78438238) + (con bls12_381_G2_element 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 123) + (con bls12_381_G2_element 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03a/multiScalarMul-03a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc new file mode 100644 index 00000000..ab308e51 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = ((((n1*p1+n2*p2)+n3*p3)+n4*p4)+n5*p5)+n6*p6 +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc) + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 34527457238) + (con bls12_381_G2_element 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer -7) + (con bls12_381_G2_element 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 78438238) + (con bls12_381_G2_element 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f) + ] + ] + [(builtin bls12_381_G2_scalarMul) + (con integer 123) + (con bls12_381_G2_element 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-03b/multiScalarMul-03b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc new file mode 100644 index 00000000..7bc08c2e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc @@ -0,0 +1,60 @@ +-- Multi-scalar multiplication is itertated multiply-and-add, invariant under permutation and association. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n4*p4+((n3*p3+n1*p1)+(n6*p6+(n2*p2+n5*p5))) +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n4*p4 + (con integer -7) + (con bls12_381_G2_element 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n3*p3 + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d) + ] + [(builtin bls12_381_G2_scalarMul) -- n1*p1 + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72) + ] + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n6*p6 + (con integer 123) + (con bls12_381_G2_element 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n2*p2 + (con integer 34527457238) + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + [(builtin bls12_381_G2_scalarMul) -- n5*p5 + (con integer 78438238) + (con bls12_381_G2_element 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31) + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04a/multiScalarMul-04a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc new file mode 100644 index 00000000..48d1d91c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc @@ -0,0 +1,61 @@ +-- Multi-scalar multiplication is itertated multiply-and-add, invariant under permutation and association. +-- msm [n1,n2,n3,n4,n5,n6] [p1,p2,p3,p4,p5,p6] = n4*p4+((n3*p3+n1*p1)+(n6*p6+(n2*p2+n5*p5))) +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n4*p4 + (con integer -7) + (con bls12_381_G2_element 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n3*p3 + (con integer 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234) + (con bls12_381_G2_element 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c) + ] + [(builtin bls12_381_G2_scalarMul) -- n1*p1 + (con integer -7843724524521392138901923801823923123123454352157) + (con bls12_381_G2_element 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc) + ] + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n6*p6 + (con integer 123) + (con bls12_381_G2_element 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9) + ] + [(builtin bls12_381_G2_add) + [(builtin bls12_381_G2_scalarMul) -- n2*p2 + (con integer 34527457238) + (con bls12_381_G2_element 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a) + ] + [(builtin bls12_381_G2_scalarMul) -- n5*p5 + (con integer 78438238) + (con bls12_381_G2_element 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f) + ] + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-04b/multiScalarMul-04b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc new file mode 100644 index 00000000..caf1ac03 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc @@ -0,0 +1,50 @@ +-- msm (n:ns) (p:ps) = n*p + msm ns ps +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + [(force (builtin mkCons)) + (con integer -7843724524521392138901923801823923123123454352157) + (con (list integer) + [ 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + ] + [(force (builtin mkCons)) + (con bls12_381_G2_element 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72) + (con (list bls12_381_G2_element) + [ 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05a/multiScalarMul-05a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc new file mode 100644 index 00000000..cbb75416 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc @@ -0,0 +1,51 @@ +-- msm (n:ns) (p:ps) = n*p + msm ns ps +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + [(force (builtin mkCons)) + (con integer -7843724524521392138901923801823923123123454352157) + (con (list integer) + [ 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + ] + [(force (builtin mkCons)) + (con bls12_381_G2_element 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc) + (con (list bls12_381_G2_element) + [ 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-05b/multiScalarMul-05b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc new file mode 100644 index 00000000..014a9711 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc @@ -0,0 +1,20 @@ +-- First argument is empty list => result = zero +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) [] + ) + (con (list bls12_381_G2_element) + [0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06a/multiScalarMul-06a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc new file mode 100644 index 00000000..85576f10 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc @@ -0,0 +1,22 @@ +-- First argument is empty list => result = zero +-- No infinite points in the input. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) [] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + , 0xb0e08d2a910873031575e122ffcb2995dfd37f1e9007ec252f0823fde588bbefd147a116e55aa34e841ebd3cd42e39ba0b650cefbdf0b98700f5767d9b2dd6dbde3130aad14568e22ddc1ada7f5cf8c7a345289c4dc23edfd16b4acaf8e9114d + ] + ) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-06b/multiScalarMul-06b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc new file mode 100644 index 00000000..0e0a8a4b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc @@ -0,0 +1,18 @@ +-- Second argument is empty list => result = zero +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) []) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-07/multiScalarMul-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc new file mode 100644 index 00000000..54d86a03 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc @@ -0,0 +1,10 @@ +-- Both arguments are empty lists => result = zero +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) []) + (con (list bls12_381_G2_element) []) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-08/multiScalarMul-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc new file mode 100644 index 00000000..759c52e4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc @@ -0,0 +1,52 @@ +-- Extra entries at end of first list are ignored +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G2_element) + [0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09a/multiScalarMul-09a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc new file mode 100644 index 00000000..149d670a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc @@ -0,0 +1,53 @@ +-- Extra entries at end of first list are ignored +-- No infinite points in the input +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-09b/multiScalarMul-09b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc new file mode 100644 index 00000000..d54dee7d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc @@ -0,0 +1,63 @@ +-- Extra entries at end of second list are ignored +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + , 0x943dbecd08356be2b3235193f810e48e127587a715c55f6e81d8445d9b729c5ea31c14ba74e8adb53c890dbe97c4730f00129b538630aab10d5b3ca30fcf16dc3d6372cf4353f10ae77dc93719e3c2f110aea0bfbabcefc63ff7848094f5d8f8 + , 0xb2d382a4a1e4437e7a74c03044d4595f7b7ec2a72f8c6228c7c7c798f02548e5b8984736c31b5cbed8a89c14e4e01ed006ecf7f35ed8fc39438322da06340a49a1f44b90d525e62412c7897cd5184206a05392f3e94347656408dd06b28137e9 + , 0xb8e139bf0d4a6eda83d89e479c3660f35f2261ddf063836b5fb160fb72ff5a1287f7775d578bbcf813c1fdd0709ba4b702ea158ebe4613c551f7245cca884951dcaf992794a8d40e5342b74c685500b501549fa5e969a9d7cdca6549911f91a5 + , 0xa9777bcb87b16dfb70c0c80e970a24090434945eb41c21b5120606cf571e9f74905aec7668e26f48bc20f574903f62ca0ba8078128850be1997d67e3658f749daf6495f9205caeb14cf762a81e203e7aaed907ebbcd87f3a7d7c5d53538cb169 + , 0xb7aa0a2dc0be429ce698d956b2bc99a77c4d1257211b17f380dff9da3926b99770d37c40b13594e33e3369d20c616b961510fbb8a7ef9da9f1407372a1a0290bb9fc5b2ace70dbddf6a61bddc80d311b6bd689da2235f200085d0830a6c98049 + , 0x88298c59ee776c2fde1deda340c7119eaf9f6517c563706aa2e6b86c0430fdb2c7bd9d1b8719395afd92eabdcb9fd42e03268578834b50ecb247688a0b13280fd860f4a5433f210553480a2f6be7ea746879bbe6e8010cbda99c7bb35a48998b + , 0xa62ff87e08bceda8bf96bfb8e962ad92c9f93c640b883a71cc4f739fcf1fe003ecc9ad90f4bef3ef8217a1da038504db003f81c4e3d45c2120acad72cd130e7f61036bbf3719329f8dffca2b82041db82698e44089f495ee3782788873b8beb3 + , 0xb4d13b153e7d935779a3fc6a04838945ddaa8231a6a51f855945410b98bbbc2f49f5a2a44fee9839f449260fa5a0b87610f7751e7d634ef4e706d7fcaf65d6a80074a6ef0a47999b9f66c4f246a3d7606a2565236482478148d6f1f46ff6e029 + , 0x8241d80bdf4a366b9f2ea792cb008fbfd658ed427355612b8c417d65e111bfecbd620fd8f93690377a15a5b02a2c420707a345cf90ac0c9bd54750bd683b43b9a9c561296697535ffac4928378dce5fb1a319e0fb2701569571513ea226ab485 + , 0xb9cc2902ba7857f14ab0b367a583911bf13e9c5a022573d0fbe46e3d9da11f8f75a793bd077cfa22f8a85efbe57b383907a41a4e2b27e8dcc496dc4dfcbc3ffbaadd090e70f4c0a45d8fc6475d7c964d03c7c9ffd8e6d443026dbbae0876bdd8 + , 0xa7d03c61d6ee8c5156ec85c149b9c86f2450d2c008632b365ac026312fc34df3e2fde0fe8d2b3eb86f7b8063a683fb840231ab995d7dd953601fce9127f6d4abcd2d7d32c763cb9a0708b639ef2b323ca3a1da9f18f5779dfa9306031b14ef2b + , 0xb2f52b4367b8db736eb02e07922655ef588a451c5cfe7da306900009e2aef25c27d8626e02651adafb18d9f830a641270e785ede2da301e466126c4c028e8de4def7aef6a780b6460011e14252c1d597f35a0fb43ef7765ef611b5cee97cd48e + , 0x98636338d9ebb95b5011fbc2eba2c321b2bc1913261e9a73666682d6bfef7e364953a313ff289b86fbfba354996365de0c924c9bd7661d28eba7c1be86d22d2002f1008cb52859147ddfe985e36f454fcdc2b54a5892ab38158dbc55ad307114 + , 0xa68621de27aa44a2d6a020ab7c939eba8260f8cca1b90664df123086d5cfc1caae9ce4587bbc4ed3d41e9e7a7396e0bf06ae9edc1b8df7391bb45516a340e1e224bb2f3a4dad5458c2798864a17adc2549979f771e00a44001c607a31e113c2c + , 0x94569a88243005f2d1cc2d2c09d718e08ab9c885ea4c8701c8138d5e04c2acf3232d6b599eb0ef44c44959a70314636b04adee0bf73eec634d86e34fe04409477b1a5faa19065d29a35c422b3184be32781b6d8cdae6e56367de17e77cc7b9c2 + , 0x9624fc935bfb67b79e0cd1926a64551b759a5a10fb08ecfcdcd671e02079279ef7336c812656980bf7dfb90385121075108025b1395a756e39329226e0a723d2d04d22b5cc2262b92c89d62b28820f20a2821dabb6a97fe845a1459d7bc06bfa + , 0xb4012b944ba173d80f4906f72b9e2c112135509a53e221eadd7872f70e9977e6575c859a0282ffa782dcdcb126f08e0c0f742a3d8abb9d965be247c53c681c82ff5f32d67811bee7b4f4881d6f98b8cad14bc184ff1fc01daf298426efa83c59 + , 0x90ee04e53207080da82a6ee4208bea5955befdf1a347936c1d0c3d25daf722ae5009dab1ac1fcb1a627e37250829005a18b67c291dc769756ebd6ca2211831972f62a5ac2049c1fd3512789e7271002e1609ca6d63690be3c36794f0ffee36e9 + ] + ) + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10a/multiScalarMul-10a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc new file mode 100644 index 00000000..3f91060d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc @@ -0,0 +1,74 @@ +-- Extra entries at end of second list are ignored +-- No infinite points in the input +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + , 0xb0e08d2a910873031575e122ffcb2995dfd37f1e9007ec252f0823fde588bbefd147a116e55aa34e841ebd3cd42e39ba0b650cefbdf0b98700f5767d9b2dd6dbde3130aad14568e22ddc1ada7f5cf8c7a345289c4dc23edfd16b4acaf8e9114d + , 0x89168aec9141a528a2af6c19bed3a66dfc6a435df428567d7d301ed576741cccba6affb3ab375458b31a1bf0339dc3ea173da147d3ee1d59cd846f9a46fe01fa8271f6b3d5c0a81196bf75f2b255558a62aa420de2ff630d9188a53e7db18126 + , 0xaf1a99fa174fba3308113b4b4e7390dd26ab74cedbff3ee8b644e08e984ed342469ac63ef3bd039f88d58ff18f5a02d301700660da0accc94ada480b297dbe148f2fcb71644924895d6af629c85e94c78523de38ead1a529e06e5d48c57044fe + , 0x891d50955b2a3a15a10a04e2e4ceb02f7f1d1a64524ef46bdc0942bcdbad6ef0c8c0d05d2d989334afe9bd4def2e453f03fbc55556162a46de0e01811007a0160dc67ef81e25849106c342f666d38b143752d2be182427daf1b2ec24ea21868d + , 0x96fdaa66f3059b9a3f6f546e0bd5b1a3249462477ddd686c5d1437cf5902073a9cb43eb3be1986a4fd9635252766738903ec021af628695d2baefe72ca5c10feff83190e9120d62c217de6502dd4185e68da13237d4438596e914e272eb865b4 + , 0xa4415ae3d0ca7eea635fc55dd1e38b4827043fc7858f4f6a1f52b93ca0711da461467f2b8a0a24e786d7cb6f4d074d7d17ec77d2f6766a3c1d926a3674d6901194539991067b8b26f051c5276df544297fed090cae6a26b51a1d3dc5b69e81fc + , 0x887fa9287582cfbff8ce0854c7d20c42554ea708904c6aed644f4285c1cbc60e3f76c6cca90f9b842c13141bd4e712fd17f858dfcae10a7ad7ebb9cf46b69ac36d09aafa8ce00e84c8e84f25aafe2c231f766a23743a1a2ad37f6d3bf8f2922d + , 0xb06535688fc82678216bf23b83612c9514d384565456e2b6073d1b7e1f4d4bbad76340e1c22a41f2630a4ad17d4bbd6c187bd109d4d98b90127e11f8b3a264bcaf0ec40c6e291078ca6ab5949b59438f93c81bc94e01e0a041bef7d5822d8ca4 + , 0xa529fa7bd0044e5c9c8689db9b53c9f68477806722ece5704858d568e95a80efad1a9e92ab903edff253b458b00719cf0fcde2e787be8bea62018ebb99ef0a5041c6113af404d4dec82febaaad51fed3f24311e525547f713bf2ad3e22ea9824 + , 0xaf075c54963ec62f309503b4e5d36bce1d4b63240f9510320488c900dec9c397c1367d9ee57a3d53946ee5ed34275b0804051916bf0ddee86f5eebcb8424715bf572e58ffd42ac5dff4b0a2c45317ff525d5b1f132df195f8c7d1221e70389ab + , 0x82d6f5d34005aa1cf956b94cce3ece20e65b3a13d0b72dcf49b62cb6f9863b69e2a9b3a4a0e2463c7270c09b702c0755161eaa339270343052c445dd6375104ec74d2c9909fa2684fc08afdbf749df4cf39c331ab40645a897bb042ec90f7fcc + , 0xa24f0ae224ac95ce83d2a456c80253a18e1a3f23b48acb3a15d0314c0973582c391726733b7662f88828541b5c14730e0b80d6454b5af812c77d5f66c632c44b801b9799a847ebe64ee5cfeb95a7b0d6ce827ff8c0212f28227b6217a4c90628 + , 0x99226c14b4715c9d2ef61761d8907b950dadddfae62df0da328cbb94ac52df2ac8e0a2d3d177f70fe36c0be43ccc9fba17ba6528070da4600d590c6ca85da45f3a16a1eb635394b2891aaee1f87f8df9a8f2e886415ca28789715a2160986c9e + , 0xb7238802324d78275a18eb92d46f5d05b4d294699b23674e197e0ca570606f2bc52a869b6f1f14a154c2f16ebf8d613a18d6fb31d4b00a88cea163ef99ac8fdaf57b920c477e21a0569fc0381910325af2dae0b9fab3f32ac55fb4c3dd6cc2a8 + , 0xb5be37277606309cccfee0350cbbf16e6aec1594757bf3bd6774ca4bd0b1e251c05083af176e76be6057c811e0ebe1830135465a227a5ed9c60b1b70f9f047b7a00c3aa2509128ea98014e992f7a44e7e3670b416dc87760e45a5f7204964725 + , 0x995efe64d2c9adc79aba99e2fda526791d34751f6fd16035068bbc081bc6a749d0e672b3a245cef28ded81ce2f5d877b0311644ad229bf6676660b7bd0117f54452463d7194d3cbe8d8ade6a66dade6bb305af94cfc87165e468cb483c4da9a6 + , 0x80bd6902a9d41c72c2d5e7a0b12e7a836551264e87aa0a4c21b8763461644f919345573e30401eee41364a29be7cb4b3109b6590e9a1e0960cf64b7e8be8d71fbb7c27a45cc5b11c3435c6e6e30fc12ac4b4e644e668b6f90fb21c0a2d1842f2 + , 0x8da1a61a0fbe11e9aa908a5807b4fb3dd30cec0a5d0a26c7a712005f51c79346868aede4fc8a1a06b5694717737a25060c10bd6b1a04af4f301ed6dbf5b4bcde0f6361735499b4e43e50f4f655002c3e416eafb5a9b0c5aa24f9200acd4d916b + , 0xb927c864b95ac72e8369b863d6ac3619fcdc271600e888de2b6bd22ec6d56856ae66c22fd355954d7de49e94cac8381b19b4ae0788216b46c69053fb241a8b711a94db4d422ac35f40fc17ba2c15a268c057d5ecccc2a5d95237e980ee58cd2d + , 0xaa081687880f49f2f9538bde1a85509e1ee734f034bbd5c2a200685f85e86c4fcf567e1dde6cdbe98e1e41dc9531b05b113e9748ff4ce4b26ee481080d4a4696788a8a3530a05182581021581a6e8ea9be054a8829e0141259fafd0c7a03079a + , 0xabe37569213600dc672625217628e027d6dcf20231765719170748ff9fdf497b18559faad92ce36288d8973ad38d238900256c493ce2754c65a2cfb3b4051bf1b5d7acad5e660abeb6332e03e39d477ccc9dd58804ec6a113a988047cef56ded + , 0x8da76f80f4d103593029be5fd3f8f2065d44570944dcf016f6618dc1daff3c746969d7ed64987baf4708470c5909a89813391f534f79700dbf7552ba9a12c869d5c47aa145b1e7fce1dec881a6c8b935b0c7e170be146b2c25bedee1b147effb + , 0x8ed9852e3110b36ff50361b7fd3af72348f583746ff050312060ecd887affeb47157236bb262101cb5ccc28d8c8915710741f1e7c703436d27cfd1c64547d8fe0c5553979fe1ed17945bbf54295b3379e04aba84fc0515b56418e234611565f9 + , 0xa09c46fd8c6a73ba57a83419b0053f8c813b0be8a9123cb15ca718e22ae6513e493193d9de3230dbae2b1eabfbc00c630f4e42734c6dccb069d47a5a46bffcbf5ae25be2aef0cb9658220bfba98b9a9f1dd7f03a7f400434ae3c5ee3431dbbfe + , 0xa088e762b3ed25ed0a3e187781fb7eefb3112873f1d8d1459afbf4cf9acf3677f9fdd7005d22111589f7982dea7a579a055a844f0723dd3797d77f744164b1e122dab0fbff2e9d6491d43ac13602f9c31798f45cc25800001efd1551c30c70a0 + , 0xa060e6516f5f22b813c8063ea127c59154e862e1756cd8b08590b6942630cb7be941d17e6ceed1a76d5764340d3a29620d8e4dd743ecda99c2e2ba5d3685c234fc5151293ec147ce74c89e80ff6721da2e26a667833b32837ae9de953452fdee + , 0xb111c8b9f0ac8ef8e68f036183539b4b785d6d4ea664b6b809e8363a05656b79c9e7dcd337ebb5049eeb508cfe241736026929e0a12cc08cba938a27a492f7be499d2b6b35a4464b20c4dd83db53456c564931f3434165fa9dda3fa69b771e08 + , 0x888dbfd7414c79a8210c9495dea625928f693b706130813fb411be3a9db873ddbf88508fdc8f7b2ee9329df292b8ed0b053d96291ff18dea28ee08fe24c3d823f3c3dacbcc6b3c5d15a76ffbe80d3fe737a773bcb75dbe39cd9529b56de056de + ] + ) + ] + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + ] + ) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-10b/multiScalarMul-10b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc new file mode 100644 index 00000000..4d626834 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc @@ -0,0 +1,47 @@ +-- All entries in second list are the zero point => result is the zero point +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 78438238 + , 123 + , 1 + , 82394290214 + , -2148234234 + , 0 + , -9962138123 + , 555555 + , 1000 + ] + ) + (con (list bls12_381_G2_element) + [ 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ] + ) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-11/multiScalarMul-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc new file mode 100644 index 00000000..91eeea11 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc @@ -0,0 +1,35 @@ +-- All entries in the first list are zero => result is the zero point. +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + , 0x943dbecd08356be2b3235193f810e48e127587a715c55f6e81d8445d9b729c5ea31c14ba74e8adb53c890dbe97c4730f00129b538630aab10d5b3ca30fcf16dc3d6372cf4353f10ae77dc93719e3c2f110aea0bfbabcefc63ff7848094f5d8f8 + , 0xb2d382a4a1e4437e7a74c03044d4595f7b7ec2a72f8c6228c7c7c798f02548e5b8984736c31b5cbed8a89c14e4e01ed006ecf7f35ed8fc39438322da06340a49a1f44b90d525e62412c7897cd5184206a05392f3e94347656408dd06b28137e9 + , 0xb8e139bf0d4a6eda83d89e479c3660f35f2261ddf063836b5fb160fb72ff5a1287f7775d578bbcf813c1fdd0709ba4b702ea158ebe4613c551f7245cca884951dcaf992794a8d40e5342b74c685500b501549fa5e969a9d7cdca6549911f91a5 + , 0xa9777bcb87b16dfb70c0c80e970a24090434945eb41c21b5120606cf571e9f74905aec7668e26f48bc20f574903f62ca0ba8078128850be1997d67e3658f749daf6495f9205caeb14cf762a81e203e7aaed907ebbcd87f3a7d7c5d53538cb169 + , 0xb7aa0a2dc0be429ce698d956b2bc99a77c4d1257211b17f380dff9da3926b99770d37c40b13594e33e3369d20c616b961510fbb8a7ef9da9f1407372a1a0290bb9fc5b2ace70dbddf6a61bddc80d311b6bd689da2235f200085d0830a6c98049 + , 0x88298c59ee776c2fde1deda340c7119eaf9f6517c563706aa2e6b86c0430fdb2c7bd9d1b8719395afd92eabdcb9fd42e03268578834b50ecb247688a0b13280fd860f4a5433f210553480a2f6be7ea746879bbe6e8010cbda99c7bb35a48998b + , 0xa62ff87e08bceda8bf96bfb8e962ad92c9f93c640b883a71cc4f739fcf1fe003ecc9ad90f4bef3ef8217a1da038504db003f81c4e3d45c2120acad72cd130e7f61036bbf3719329f8dffca2b82041db82698e44089f495ee3782788873b8beb3 + , 0xb4d13b153e7d935779a3fc6a04838945ddaa8231a6a51f855945410b98bbbc2f49f5a2a44fee9839f449260fa5a0b87610f7751e7d634ef4e706d7fcaf65d6a80074a6ef0a47999b9f66c4f246a3d7606a2565236482478148d6f1f46ff6e029 + , 0x8241d80bdf4a366b9f2ea792cb008fbfd658ed427355612b8c417d65e111bfecbd620fd8f93690377a15a5b02a2c420707a345cf90ac0c9bd54750bd683b43b9a9c561296697535ffac4928378dce5fb1a319e0fb2701569571513ea226ab485 + , 0xb9cc2902ba7857f14ab0b367a583911bf13e9c5a022573d0fbe46e3d9da11f8f75a793bd077cfa22f8a85efbe57b383907a41a4e2b27e8dcc496dc4dfcbc3ffbaadd090e70f4c0a45d8fc6475d7c964d03c7c9ffd8e6d443026dbbae0876bdd8 + , 0xa7d03c61d6ee8c5156ec85c149b9c86f2450d2c008632b365ac026312fc34df3e2fde0fe8d2b3eb86f7b8063a683fb840231ab995d7dd953601fce9127f6d4abcd2d7d32c763cb9a0708b639ef2b323ca3a1da9f18f5779dfa9306031b14ef2b + , 0xb2f52b4367b8db736eb02e07922655ef588a451c5cfe7da306900009e2aef25c27d8626e02651adafb18d9f830a641270e785ede2da301e466126c4c028e8de4def7aef6a780b6460011e14252c1d597f35a0fb43ef7765ef611b5cee97cd48e + , 0x98636338d9ebb95b5011fbc2eba2c321b2bc1913261e9a73666682d6bfef7e364953a313ff289b86fbfba354996365de0c924c9bd7661d28eba7c1be86d22d2002f1008cb52859147ddfe985e36f454fcdc2b54a5892ab38158dbc55ad307114 + , 0xa68621de27aa44a2d6a020ab7c939eba8260f8cca1b90664df123086d5cfc1caae9ce4587bbc4ed3d41e9e7a7396e0bf06ae9edc1b8df7391bb45516a340e1e224bb2f3a4dad5458c2798864a17adc2549979f771e00a44001c607a31e113c2c + , 0x94569a88243005f2d1cc2d2c09d718e08ab9c885ea4c8701c8138d5e04c2acf3232d6b599eb0ef44c44959a70314636b04adee0bf73eec634d86e34fe04409477b1a5faa19065d29a35c422b3184be32781b6d8cdae6e56367de17e77cc7b9c2 + , 0x9624fc935bfb67b79e0cd1926a64551b759a5a10fb08ecfcdcd671e02079279ef7336c812656980bf7dfb90385121075108025b1395a756e39329226e0a723d2d04d22b5cc2262b92c89d62b28820f20a2821dabb6a97fe845a1459d7bc06bfa + , 0xb4012b944ba173d80f4906f72b9e2c112135509a53e221eadd7872f70e9977e6575c859a0282ffa782dcdcb126f08e0c0f742a3d8abb9d965be247c53c681c82ff5f32d67811bee7b4f4881d6f98b8cad14bc184ff1fc01daf298426efa83c59 + ,0x90ee04e53207080da82a6ee4208bea5955befdf1a347936c1d0c3d25daf722ae5009dab1ac1fcb1a627e37250829005a18b67c291dc769756ebd6ca2211831972f62a5ac2049c1fd3512789e7271002e1609ca6d63690be3c36794f0ffee36e9 + ] + ) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12a/multiScalarMul-12a.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc new file mode 100644 index 00000000..171f5b8a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc @@ -0,0 +1,47 @@ +-- All entries in the first list are zero => result is the zero point. +-- No infinite points in the input +(program 1.0.0 + [(builtin bls12_381_G2_equal) + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) + (con (list bls12_381_G2_element) + [ 0xad41aace92b82f4b7d30a15dc3ac13507b3572a616558e0eb4b949a1fd050dabff883041c54ca3f4a94c54178361caca0aa1b0cab47de840e0a8e622c940e4db0cc14bc4ce858c20d68942eb93be6ce3f722fe88cfeb68de9aec49016c6e11bc + , 0x91b291669f343a59284bef0cf52709729128fdbd0ba244d47c939674deae2ba2645e244052817e2d5546da21691a31b90da3bed5f314e294e0cdc2f9eb265f33046a99baec694c0e2b152e2488fbf6dc28d4b33648d93e1a0ab25d4e82a3518a + , 0xa573452698f1138122ef92ebc7f7a8bb89d3128138bc04577ac4259a3e490e89cccccdd42429c7a19669529ae367f2e216856ddcbc16245c55d300842f51cd00d0fa8db91860a2040a7f67a35249c2ad961a941cab9ede632e8ccd4a62429a8c + , 0x9211d9c41e29c8e9f5cd37bdd9c48f78bae00214c08121332592a3cfa1a58985ded9d2bed17b07b3ac8bf2e41708eb48044b1b42ecec87d44ff20542a86812b84d0b7bbad920c165cd80948ff06efc5e3852350aea5768c6de5b333170cc1687 + , 0xa259ebf87ffba6b7f678b05623726b000b5265c8ff686370fb98080d07a718d93a034efd952d66b11777ba6ac38c3d3408329f6d86ec0d78c7f95128556e5b64af367db1804ec977394b1c8b20b5d261b84a0d0ee2747512109af3fa9a90a54f + , 0x82e73ef3ad81c07276a8b9360b1349dca861cf3c11d7e3d3da23b1525d683bb187429283a3200156af1301f6ef32697a1479aec5736853f591095cf15ab9507c71a77bd579bb2e5f4cab94d8ff33bc43fcf336136aa2face28f1886b62f3cca9 + , 0xb0e08d2a910873031575e122ffcb2995dfd37f1e9007ec252f0823fde588bbefd147a116e55aa34e841ebd3cd42e39ba0b650cefbdf0b98700f5767d9b2dd6dbde3130aad14568e22ddc1ada7f5cf8c7a345289c4dc23edfd16b4acaf8e9114d + , 0x89168aec9141a528a2af6c19bed3a66dfc6a435df428567d7d301ed576741cccba6affb3ab375458b31a1bf0339dc3ea173da147d3ee1d59cd846f9a46fe01fa8271f6b3d5c0a81196bf75f2b255558a62aa420de2ff630d9188a53e7db18126 + , 0xaf1a99fa174fba3308113b4b4e7390dd26ab74cedbff3ee8b644e08e984ed342469ac63ef3bd039f88d58ff18f5a02d301700660da0accc94ada480b297dbe148f2fcb71644924895d6af629c85e94c78523de38ead1a529e06e5d48c57044fe + , 0x891d50955b2a3a15a10a04e2e4ceb02f7f1d1a64524ef46bdc0942bcdbad6ef0c8c0d05d2d989334afe9bd4def2e453f03fbc55556162a46de0e01811007a0160dc67ef81e25849106c342f666d38b143752d2be182427daf1b2ec24ea21868d + , 0x96fdaa66f3059b9a3f6f546e0bd5b1a3249462477ddd686c5d1437cf5902073a9cb43eb3be1986a4fd9635252766738903ec021af628695d2baefe72ca5c10feff83190e9120d62c217de6502dd4185e68da13237d4438596e914e272eb865b4 + , 0xa4415ae3d0ca7eea635fc55dd1e38b4827043fc7858f4f6a1f52b93ca0711da461467f2b8a0a24e786d7cb6f4d074d7d17ec77d2f6766a3c1d926a3674d6901194539991067b8b26f051c5276df544297fed090cae6a26b51a1d3dc5b69e81fc + , 0x887fa9287582cfbff8ce0854c7d20c42554ea708904c6aed644f4285c1cbc60e3f76c6cca90f9b842c13141bd4e712fd17f858dfcae10a7ad7ebb9cf46b69ac36d09aafa8ce00e84c8e84f25aafe2c231f766a23743a1a2ad37f6d3bf8f2922d + , 0xb06535688fc82678216bf23b83612c9514d384565456e2b6073d1b7e1f4d4bbad76340e1c22a41f2630a4ad17d4bbd6c187bd109d4d98b90127e11f8b3a264bcaf0ec40c6e291078ca6ab5949b59438f93c81bc94e01e0a041bef7d5822d8ca4 + , 0xa529fa7bd0044e5c9c8689db9b53c9f68477806722ece5704858d568e95a80efad1a9e92ab903edff253b458b00719cf0fcde2e787be8bea62018ebb99ef0a5041c6113af404d4dec82febaaad51fed3f24311e525547f713bf2ad3e22ea9824 + , 0xaf075c54963ec62f309503b4e5d36bce1d4b63240f9510320488c900dec9c397c1367d9ee57a3d53946ee5ed34275b0804051916bf0ddee86f5eebcb8424715bf572e58ffd42ac5dff4b0a2c45317ff525d5b1f132df195f8c7d1221e70389ab + , 0x82d6f5d34005aa1cf956b94cce3ece20e65b3a13d0b72dcf49b62cb6f9863b69e2a9b3a4a0e2463c7270c09b702c0755161eaa339270343052c445dd6375104ec74d2c9909fa2684fc08afdbf749df4cf39c331ab40645a897bb042ec90f7fcc + , 0xa24f0ae224ac95ce83d2a456c80253a18e1a3f23b48acb3a15d0314c0973582c391726733b7662f88828541b5c14730e0b80d6454b5af812c77d5f66c632c44b801b9799a847ebe64ee5cfeb95a7b0d6ce827ff8c0212f28227b6217a4c90628 + , 0x99226c14b4715c9d2ef61761d8907b950dadddfae62df0da328cbb94ac52df2ac8e0a2d3d177f70fe36c0be43ccc9fba17ba6528070da4600d590c6ca85da45f3a16a1eb635394b2891aaee1f87f8df9a8f2e886415ca28789715a2160986c9e + , 0xb7238802324d78275a18eb92d46f5d05b4d294699b23674e197e0ca570606f2bc52a869b6f1f14a154c2f16ebf8d613a18d6fb31d4b00a88cea163ef99ac8fdaf57b920c477e21a0569fc0381910325af2dae0b9fab3f32ac55fb4c3dd6cc2a8 + , 0xb5be37277606309cccfee0350cbbf16e6aec1594757bf3bd6774ca4bd0b1e251c05083af176e76be6057c811e0ebe1830135465a227a5ed9c60b1b70f9f047b7a00c3aa2509128ea98014e992f7a44e7e3670b416dc87760e45a5f7204964725 + , 0x995efe64d2c9adc79aba99e2fda526791d34751f6fd16035068bbc081bc6a749d0e672b3a245cef28ded81ce2f5d877b0311644ad229bf6676660b7bd0117f54452463d7194d3cbe8d8ade6a66dade6bb305af94cfc87165e468cb483c4da9a6 + , 0x80bd6902a9d41c72c2d5e7a0b12e7a836551264e87aa0a4c21b8763461644f919345573e30401eee41364a29be7cb4b3109b6590e9a1e0960cf64b7e8be8d71fbb7c27a45cc5b11c3435c6e6e30fc12ac4b4e644e668b6f90fb21c0a2d1842f2 + , 0x8da1a61a0fbe11e9aa908a5807b4fb3dd30cec0a5d0a26c7a712005f51c79346868aede4fc8a1a06b5694717737a25060c10bd6b1a04af4f301ed6dbf5b4bcde0f6361735499b4e43e50f4f655002c3e416eafb5a9b0c5aa24f9200acd4d916b + , 0xb927c864b95ac72e8369b863d6ac3619fcdc271600e888de2b6bd22ec6d56856ae66c22fd355954d7de49e94cac8381b19b4ae0788216b46c69053fb241a8b711a94db4d422ac35f40fc17ba2c15a268c057d5ecccc2a5d95237e980ee58cd2d + , 0xaa081687880f49f2f9538bde1a85509e1ee734f034bbd5c2a200685f85e86c4fcf567e1dde6cdbe98e1e41dc9531b05b113e9748ff4ce4b26ee481080d4a4696788a8a3530a05182581021581a6e8ea9be054a8829e0141259fafd0c7a03079a + , 0xabe37569213600dc672625217628e027d6dcf20231765719170748ff9fdf497b18559faad92ce36288d8973ad38d238900256c493ce2754c65a2cfb3b4051bf1b5d7acad5e660abeb6332e03e39d477ccc9dd58804ec6a113a988047cef56ded + , 0x8da76f80f4d103593029be5fd3f8f2065d44570944dcf016f6618dc1daff3c746969d7ed64987baf4708470c5909a89813391f534f79700dbf7552ba9a12c869d5c47aa145b1e7fce1dec881a6c8b935b0c7e170be146b2c25bedee1b147effb + , 0x8ed9852e3110b36ff50361b7fd3af72348f583746ff050312060ecd887affeb47157236bb262101cb5ccc28d8c8915710741f1e7c703436d27cfd1c64547d8fe0c5553979fe1ed17945bbf54295b3379e04aba84fc0515b56418e234611565f9 + , 0xa09c46fd8c6a73ba57a83419b0053f8c813b0be8a9123cb15ca718e22ae6513e493193d9de3230dbae2b1eabfbc00c630f4e42734c6dccb069d47a5a46bffcbf5ae25be2aef0cb9658220bfba98b9a9f1dd7f03a7f400434ae3c5ee3431dbbfe + , 0xa088e762b3ed25ed0a3e187781fb7eefb3112873f1d8d1459afbf4cf9acf3677f9fdd7005d22111589f7982dea7a579a055a844f0723dd3797d77f744164b1e122dab0fbff2e9d6491d43ac13602f9c31798f45cc25800001efd1551c30c70a0 + , 0xa060e6516f5f22b813c8063ea127c59154e862e1756cd8b08590b6942630cb7be941d17e6ceed1a76d5764340d3a29620d8e4dd743ecda99c2e2ba5d3685c234fc5151293ec147ce74c89e80ff6721da2e26a667833b32837ae9de953452fdee + , 0xb111c8b9f0ac8ef8e68f036183539b4b785d6d4ea664b6b809e8363a05656b79c9e7dcd337ebb5049eeb508cfe241736026929e0a12cc08cba938a27a492f7be499d2b6b35a4464b20c4dd83db53456c564931f3434165fa9dda3fa69b771e08 + , 0x888dbfd7414c79a8210c9495dea625928f693b706130813fb411be3a9db873ddbf88508fdc8f7b2ee9329df292b8ed0b053d96291ff18dea28ee08fe24c3d823f3c3dacbcc6b3c5d15a76ffbe80d3fe737a773bcb75dbe39cd9529b56de056de + ] + ) + ] + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-12b/multiScalarMul-12b.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc new file mode 100644 index 00000000..b497d24f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc @@ -0,0 +1,23 @@ +-- Maximum allowed scalar is OK +(program 1.0.0 + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095167 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected new file mode 100644 index 00000000..8ec21159 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13a/multiScalarMul-13a.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xab67ebb07886cacbb206e3e8a794e8b05a3ec759821ccd8d8b587358b1b27c29e55bdb3e9da6569b32c594530b4cb047122a631c2122ccfc89188a7067c61492b6ec4d5f03fac718b29ba9b166a901a3ba2a5ca7761be2cf81117dc2d20e0274 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc new file mode 100644 index 00000000..fd2d093d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc @@ -0,0 +1,23 @@ +-- A scalar one greater than the maximum causes an error +(program 1.0.0 + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , 522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13b/multiScalarMul-13b.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc new file mode 100644 index 00000000..4382b83c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc @@ -0,0 +1,23 @@ +-- Minimum allowed scalar is OK +(program 1.0.0 + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , -522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095168 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected new file mode 100644 index 00000000..708ae6a7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13c/multiScalarMul-13c.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x90073063933782475e76b8c33226b47dc1f8c6848fa53a320b95af271d954f022e3cbe6761fcb665dc5fa897be1f8223091d40a3615a64261127e92afc21352e5ac325517cd8246918d9e9dce6f0d61365c7128f0035ddc088b7878b03d76a46 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc new file mode 100644 index 00000000..f73c979e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc @@ -0,0 +1,23 @@ +-- A scalar one less than the minimum causes an error +(program 1.0.0 + [(builtin bls12_381_G2_multiScalarMul) + (con (list integer) + [ -7843724524521392138901923801823923123123454352157 + , 34527457238 + , 941957124591735785278457826354751745783452348102412301239547134528453782352345235423452345234523452345234512341423412341234 + , -7 + , -522194440706576253345876355358312191289982124523691890192116741641976953985778728424413405967498779170445053357219631418993786719092896803631618043925682638972978488271854999170180795067191859157214035005927973113188159419698856372836167342172293308748403954352901852035642024370059304557233988891799014503343469488440893892973452815095130470299789726716411734651513348221529512507986199933857107770846917779942645743159118957217248367043905936319748237550094520674504208530837546834166925275516486044134775384991808184705966507606898412918594045916828375610659246423184062775112999150206172392431297837246097308511903252956622805412865917690043804311051417135098849101156584508839003337597742539960818209685142687562392007453579567729991395256699805775897135553415567045292136442139895777424891477161767258532611634530697452993846501061481697843891439474220308003706472837459911525285821188577408160690315522951458068463354171428220365223949985950890732881736611925133626529949897998045399734600887312408859224933727829625089164535236559716582775403784110923285873186648442456409760158728501220463308455437074192539205964902261490928669488824051563042951500651206733594863336608245755565801460390869016718045121902354170201577095169 + , 123 + ] + ) + (con (list bls12_381_G2_element) + [ 0xb889aa4128a72d8e2d62efae37ed4c93dd5500145e6e8dd532e11d2219866942e712c304086c9be5ea209028a252d5b60fbda94fe4ace6ba00c9b27ff6045df4088c89271d56b098b86e8be8fa4738008cd5edb4df9671dcc01591f87610fa72 + , 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + , 0x896020ecb559930256fc303be0060b50242b5bba144741e2ea04b22ecb2e6951b9aa8b3f17f43ef0c90346f7f932413a0b1f8f1d4daed4cdddb0fd0cfc6f7682f240408cd2974734cf150a9326f187834b9417eccb0f81e17b30921d9fcd299d + , 0xae3599a81b41ef63eeeb16e167148350d8f80cba79b3bc46ad165a78b56b9fa156a53567ec2dad87278a53f7042a0983044ef32094dab679b26a6a4fb6a34dd54f26a0d89b1881e3c49158b12d6328c3a875bfe72636229abe52bf910ec6315b + , 0xb60acb2fbd5b1ad76d6e729fdc4cde48f6e4c27a5551f23f7129996e9c35658f9093f3abb357b6a51162d7e5eab7358e1003d7d0bedc764d8f8bbacc0db5e3bbad21ab1cfa51d56c4e93477e9fe0c4a4f180a953dab36aa3ded67a6cb0118e31 + , 0xab05a108c67c0f4969338aa883efa8c3a789c8f6ec0b256d05482ce4bf9994e6c94e62b35b69b9653c1879e423d885ac0f86667d3bd6e770ec963c844e6cbd188861835ed1529ae7460fbd076f94095edff3093ffaabeb10ea69fc96e53235e3 + ] + ) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_multiScalarMul/multiScalarMul-13d/multiScalarMul-13d.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc new file mode 100644 index 00000000..470c530a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc @@ -0,0 +1,13 @@ +-- Check that adding a random point to its negative gives the zero element. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + [ + (builtin bls12_381_G2_neg) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc.expected new file mode 100644 index 00000000..145261a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/add-neg/add-neg.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc new file mode 100644 index 00000000..56cc6803 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc @@ -0,0 +1,7 @@ +-- The negative of the zero point is the zero point. +(program 1.0.0 + [ + (builtin bls12_381_G2_neg) + (con bls12_381_G2_element 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc.expected new file mode 100644 index 00000000..145261a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg-zero/neg-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc new file mode 100644 index 00000000..1894886a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc @@ -0,0 +1,7 @@ +-- Check that hashing a random bytestring gives the expected result. +(program 1.0.0 + [ + (builtin bls12_381_G2_neg) + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc.expected new file mode 100644 index 00000000..cb37047e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_neg/neg/neg.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xa310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc new file mode 100644 index 00000000..0b8eb227 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc @@ -0,0 +1,22 @@ +-- 2157p + 2157q for random points p and q in G2. This should give the same result as muladd. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_add) + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 2157) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 2157) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc.expected new file mode 100644 index 00000000..284acd1f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/addmul/addmul.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xb8a335cdbb3de744ba2b6bb3c9ad9c209a7f33a1453c2ed0460e188c1f31f185e359a62727fe1d8ba5c931d75ef644e50173e5255b62194677fb67323ce42bac5c6b1b077e682df3aabca1caee2f640db1fed0b4ad511562f7c54d84ea76debc + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc new file mode 100644 index 00000000..7c7a68d7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc @@ -0,0 +1,10 @@ +-- Check that multiplication by the scalar 44 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 44) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc.expected new file mode 100644 index 00000000..3597841c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-44/mul-44.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xaa2a95bc9936c61f5039cc6fbbe0e25fa8b1528ea18c5be09c93ed941d1c9052597086b8d3b3b5fbbd110ce389378c5414efd310de2120a7efbaaf70d01f5b80835118c1f39a4273a10f1f2a4af0ed33a7c17fba4c8e3f7cb08a1d97e82d5611 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc new file mode 100644 index 00000000..41555d76 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc @@ -0,0 +1,10 @@ +-- Check that the result of multiplying by -1 is as expected. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer -1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc.expected new file mode 100644 index 00000000..cb37047e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-neg-one/mul-neg-one.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xa310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc new file mode 100644 index 00000000..f63ae4a7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc @@ -0,0 +1,10 @@ +-- Scalar multiplication by 1 leaves a random point unchanged. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc.expected new file mode 100644 index 00000000..a89b74d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-one/mul-one.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc new file mode 100644 index 00000000..f8cad427 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc @@ -0,0 +1,10 @@ +-- Multiplication by the zero scalar gives the zero point of G2. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 0) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc.expected new file mode 100644 index 00000000..145261a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul-zero/mul-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc new file mode 100644 index 00000000..545d5e60 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc @@ -0,0 +1,22 @@ +-- 19p+25p for a random point p in G2. This should give the same result as mul44. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_add) + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 19) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 25) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc.expected new file mode 100644 index 00000000..3597841c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul19+25/mul19+25.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xaa2a95bc9936c61f5039cc6fbbe0e25fa8b1528ea18c5be09c93ed941d1c9052597086b8d3b3b5fbbd110ce389378c5414efd310de2120a7efbaaf70d01f5b80835118c1f39a4273a10f1f2a4af0ed33a7c17fba4c8e3f7cb08a1d97e82d5611 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc new file mode 100644 index 00000000..a85dfe79 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc @@ -0,0 +1,16 @@ +-- 4*(11*p) for a point in G2. This should give the same result as mul44. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 4) + ] + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 11) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc.expected new file mode 100644 index 00000000..3597841c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mul4x-11/mul4x-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xaa2a95bc9936c61f5039cc6fbbe0e25fa8b1528ea18c5be09c93ed941d1c9052597086b8d3b3b5fbbd110ce389378c5414efd310de2120a7efbaaf70d01f5b80835118c1f39a4273a10f1f2a4af0ed33a7c17fba4c8e3f7cb08a1d97e82d5611 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc new file mode 100644 index 00000000..5d37d126 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc @@ -0,0 +1,16 @@ +-- n(p+q) = np + nq (n scalar, p and q random points in G2). +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer 2157) + ] + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc.expected new file mode 100644 index 00000000..284acd1f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/muladd/muladd.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xb8a335cdbb3de744ba2b6bb3c9ad9c209a7f33a1453c2ed0460e188c1f31f185e359a62727fe1d8ba5c931d75ef644e50173e5255b62194677fb67323ce42bac5c6b1b077e682df3aabca1caee2f640db1fed0b4ad511562f7c54d84ea76debc + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc new file mode 100644 index 00000000..dc2f11a7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc @@ -0,0 +1,10 @@ +-- Multiplying a random point in G2 by the scalar -44 gives the expected result. +(program 1.0.0 + [ + [ + (builtin bls12_381_G2_scalarMul) + (con integer -44) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc.expected new file mode 100644 index 00000000..22aaa867 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulneg-44/mulneg-44.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x8a2a95bc9936c61f5039cc6fbbe0e25fa8b1528ea18c5be09c93ed941d1c9052597086b8d3b3b5fbbd110ce389378c5414efd310de2120a7efbaaf70d01f5b80835118c1f39a4273a10f1f2a4af0ed33a7c17fba4c8e3f7cb08a1d97e82d5611 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc new file mode 100644 index 00000000..b9c3fc15 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc @@ -0,0 +1,14 @@ +-- Scalar multiplication by the group size should give you the zero element of the group. +(program 1.0.0 +[ + [ (builtin bls12_381_G2_equal) + [ + (builtin bls12_381_G2_scalarMul) + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513 ) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + (con bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) +] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-01/mulperiodic-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc new file mode 100644 index 00000000..134e98d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc @@ -0,0 +1,26 @@ +-- Scalar multiplication should be periodic modulo the group size +(program + 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ (builtin bls12_381_G2_scalarMul) (con integer 123) ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-02/mulperiodic-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc new file mode 100644 index 00000000..0218e359 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc @@ -0,0 +1,29 @@ +-- Scalar multiplication should be periodic modulo the group size +(program + 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + [ + [ (builtin multiplyInteger) (con integer 987654321) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ (builtin bls12_381_G2_scalarMul) (con integer 123) ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-03/mulperiodic-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc new file mode 100644 index 00000000..5bb2845d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc @@ -0,0 +1,29 @@ +-- Scalar multiplication should be periodic modulo the group size +(program + 1.0.0 + [ + [ + (builtin bls12_381_G2_equal) + [ + [ + (builtin bls12_381_G2_scalarMul) + [ + [ (builtin addInteger) (con integer 123) ] + [ + [ (builtin multiplyInteger) (con integer -987654321) ] + (con integer 52435875175126190479447740508185965837690552500527637822603658699938581184513) + ] + ] + ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ (builtin bls12_381_G2_scalarMul) (con integer 123) ] + (con bls12_381_G2_element + 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_scalarMul/mulperiodic-04/mulperiodic-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc new file mode 100644 index 00000000..1a41b36e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc @@ -0,0 +1,7 @@ +-- This has the infinity bit set but not the compression bit, and so is invalid. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-01/bad-zero-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc new file mode 100644 index 00000000..73ec5e03 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc @@ -0,0 +1,7 @@ +-- This is the zero point of G2, but with the sign bit set. It should fail to uncompress. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #e00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-02/bad-zero-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc new file mode 100644 index 00000000..72bb6cb5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc @@ -0,0 +1,8 @@ +-- This is the zero point of G2, but with the sign bit set. It should fail to +-- uncompress. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/bad-zero-03/bad-zero-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc new file mode 100644 index 00000000..9980db48 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc @@ -0,0 +1,7 @@ +-- This contains a value which is not the x-coordinate of a point on the E2 curve. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/off-curve/off-curve.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc new file mode 100644 index 00000000..5129fc0d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc @@ -0,0 +1,8 @@ +-- This value was obtained by hashing 0x0102030405 to G2 but has had the +-- compression bit cleared, so uncompression should fail. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #28138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit1-clear/on-curve-bit1-clear.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc new file mode 100644 index 00000000..4f702a17 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc @@ -0,0 +1,9 @@ +-- This value was obtained by hashing 0x0102030405 to G2. The sign bit was set +-- but has been cleared: this negates the point, so uncompression should still +-- succeed. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #88138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected new file mode 100644 index 00000000..b6d66a53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-clear/on-curve-bit3-clear.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0x88138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc new file mode 100644 index 00000000..3bf526e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc @@ -0,0 +1,8 @@ +-- This value was obtained by hashing 0x0102030405 to G2. No changes have been +-- made, so uncompression should succeed. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #a8138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected new file mode 100644 index 00000000..578eddbd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-bit3-set/on-curve-bit3-set.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xa8138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d07 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc new file mode 100644 index 00000000..6d10d78e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc @@ -0,0 +1,10 @@ +-- This checks that the uncompression function fails on a valid *serialised* G2 +-- point (obtained by hashing 0x0102030405 onto G2). The deserialisation +-- function in the blst library can handle both serialised and compressed +-- points, but we should fail on the former. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #08138ebea766d4d1aa64dd3b5826244c32ea3fe9351f9c8d584203716dae151d14bb5d06e245c24877955c79287682ba082d077bbb2afdb1ad1d48d18e2f0c56b001bce207801adfa9fd451fc59d56f0433b02f921ba5a272c58c06536291d071676b275e27060b26dd91aac0a1feb56d1c1de7c323f486e48d54eae0c3c8f4caa45faad589c5d180ac0830dcdb3ecd8126c9c5db86cdf7129cf18582013d267a7c2827a901ef61ab58e7ef150219441abc57671eb39009f6bb166bcbade700d) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/on-curve-serialised-not-compressed/on-curve-serialised-not-compressed.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc new file mode 100644 index 00000000..10bdcaad --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc @@ -0,0 +1,8 @@ +-- This contains a value which is the x-coordinate of a point which lies on the +-- E2 curve but not the G2 subgroup. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #a00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/out-of-group/out-of-group.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc new file mode 100644 index 00000000..d7cf9568 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc @@ -0,0 +1,7 @@ +-- The bytestring is the compressed version of the G2 zero point, but extended to 97 bytes. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-long/too-long.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc new file mode 100644 index 00000000..0584bb64 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc @@ -0,0 +1,7 @@ +-- The bytestring is the compressed version of the G2 zero point, but truncated to 94 bytes. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/too-short/too-short.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc new file mode 100644 index 00000000..3e1fa7e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc @@ -0,0 +1,7 @@ +-- The zero element of G2 uncompresses correctly. +(program 1.0.0 + [ + (builtin bls12_381_G2_uncompress) + (con bytestring #c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc.expected new file mode 100644 index 00000000..145261a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_G2_uncompress/zero/zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bls12_381_G2_element + 0xc00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc new file mode 100644 index 00000000..915ed0fe --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc @@ -0,0 +1,33 @@ +-- = +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + [ (builtin bls12_381_G1_scalarMul) (con integer 251123) ] + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5 + ) + ] + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + (con + bls12_381_G1_element + 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5 + ) + ] + [ + [ (builtin bls12_381_G2_scalarMul) (con integer 251123) ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/balanced/balanced.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc new file mode 100644 index 00000000..59e8c5ce --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc @@ -0,0 +1,22 @@ +-- Check that applying finalVerify to the same two points in GT returns True. +(program 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] +] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/equal-pairing/equal-pairing.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc new file mode 100644 index 00000000..33e64ab8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc @@ -0,0 +1,52 @@ +-- = +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + [ + [ + (builtin bls12_381_G1_add) + (con + bls12_381_G1_element + 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5 + ) + ] + (con + bls12_381_G1_element + 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) + ] + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 + ) + ] + ] + [ + [ + (builtin bls12_381_mulMlResult) + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5 + ) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 + ) + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f + ) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1 + ) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/left-additive/left-additive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc new file mode 100644 index 00000000..45e479c3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc @@ -0,0 +1,22 @@ +-- Check that the results of two millerLoops of random points are different. +(program 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0xabd61864f519748032551e42e0ac417fd828f079454e3e3c9891c5c29ed7f10bdecc046854e3931cb7002779bd76d71f) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/random-pairing/random-pairing.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc new file mode 100644 index 00000000..d5e13650 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc @@ -0,0 +1,41 @@ +-- = +(program + 1.0.0 + [ + [ + (builtin bls12_381_finalVerify) + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + [ + [ + (builtin bls12_381_G2_add) + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] + ] + [ + [ + (builtin bls12_381_mulMlResult) + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G2_element 0xb0629fa1158c2d23a10413fe91d381a84d25e31d041cd0377d25828498fd02011b35893938ced97535395e4815201e67108bcd4665e0db25d602d76fa791fab706c54abf5e1a9e44b4ac1e6badf3d2ac0328f5e30be341677c8bac5dda7682f1) + ] + ] + [ + [ + (builtin bls12_381_millerLoop) + (con bls12_381_G1_element 0x950dfd33da2682260c76038dfb8bad6e84ae9d599a3c151815945ac1e6ef6b1027cd917f3907479d20d636ce437a41f5) + ] + (con bls12_381_G2_element 0x8310bc97fc7ad9b1616e51226c6a521b9d7fdf03f7299833e6a208ae0399fec76045a43ceef846e0958d0cdf05cf2b1f00460ee6edd2778b413eb7c272bc5b94d12b910f8ac4eb1b55e50a93644714787417bc462349c5e0f6f357b9ac32262a) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/bls12_381_millerLoop/right-additive/right-additive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc new file mode 100644 index 00000000..c8dae026 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc @@ -0,0 +1,4 @@ +-- A bytestring consisting entirely of zeros decodes to 0. +(program 1.0.0 + [(builtin byteStringToInteger) (con bool True) (con bytestring #00000000000000000000000000)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/all-zeros/all-zeros.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc new file mode 100644 index 00000000..88168bec --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc @@ -0,0 +1,4 @@ +-- Check that a particular bytestring decodes to the expected integer. +(program 1.0.0 + [(builtin byteStringToInteger) (con bool True) (con bytestring #123456abcdef)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc.expected new file mode 100644 index 00000000..48552a9e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/correct-output/correct-output.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 20016001699311)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc new file mode 100644 index 00000000..5b431b81 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc @@ -0,0 +1,4 @@ +-- The empty bytestring decodes to 0 +(program 1.0.0 + [(builtin byteStringToInteger) (con bool True) (con bytestring #)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/empty/empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc new file mode 100644 index 00000000..eb8a14e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc @@ -0,0 +1,7 @@ +-- Check that leading zeros don't affect the result of a big-endian decoding. +(program 1.0.0 + [(builtin equalsInteger) + [(builtin byteStringToInteger) (con bool True) (con bytestring #123456abcdef)] + [(builtin byteStringToInteger) (con bool True) (con bytestring #0000000000000000123456abcdef)] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/big-endian/leading-zeros/leading-zeros.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc new file mode 100644 index 00000000..f0b4082f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc @@ -0,0 +1,9 @@ +-- Check that the big-endian decoding of a bytestring is the same as the +-- little-endian decoding of its reverse. +(program 1.0.0 + [(builtin equalsInteger) + [(builtin byteStringToInteger) (con bool False) (con bytestring #92828b9d9e097a23ef34ba5522ee67)] + [(builtin byteStringToInteger) (con bool True) (con bytestring #67ee2255ba34ef237a099e9d8b8292)] + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/both-endian/both-endian.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc new file mode 100644 index 00000000..4f2bbb77 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc @@ -0,0 +1,4 @@ +-- A bytestring consisting entirely of zeros decodes to 0. +(program 1.0.0 + [(builtin byteStringToInteger) (con bool False) (con bytestring #00000000000000000000000000)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/all-zeros/all-zeros.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc new file mode 100644 index 00000000..6bacec71 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc @@ -0,0 +1,4 @@ +-- Check that a particular bytestring decodes to the expected integer. +(program 1.0.0 + [(builtin byteStringToInteger) (con bool False) (con bytestring #123456abcdef)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc.expected new file mode 100644 index 00000000..6d863cb8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/correct-output/correct-output.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 263666621887506)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc new file mode 100644 index 00000000..382013e3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc @@ -0,0 +1,4 @@ +-- The empty bytestring decodes to 0 +(program 1.0.0 + [(builtin byteStringToInteger) (con bool False) (con bytestring #)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/empty/empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc new file mode 100644 index 00000000..1b476362 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc @@ -0,0 +1,7 @@ +-- Check that trailing zeros don't affect the result of a little-endian decoding. +(program 1.0.0 + [(builtin equalsInteger) + [(builtin byteStringToInteger) (con bool False) (con bytestring #123456abcdef)] + [(builtin byteStringToInteger) (con bool False) (con bytestring #123456abcdef0000000000000000)] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/byteStringToInteger/little-endian/trailing-zeros/trailing-zeros.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc new file mode 100644 index 00000000..735217af --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 +[[[[[[(force (builtin chooseData)) + (con data (B #001A))] + (lam x (con integer 1))] + (lam y (con string "two"))] + (lam z3 z3)] + (lam u (con data (I 4)))] + (lam v (con data (B #05)))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc.expected new file mode 100644 index 00000000..da84ed7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataByteString/chooseDataByteString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam v-0 (con data (B #05)))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc new file mode 100644 index 00000000..d0411ca8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 +[[[[[[(force (builtin chooseData)) + (con data (Constr 1 [I 1]))] + (lam x (con integer 1))] + (lam y (con string "two"))] + (lam z3 z3)] + (lam u (con data (I 4)))] + (lam v (con data (B #05)))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc.expected new file mode 100644 index 00000000..af1702c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataConstr/chooseDataConstr.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 (con integer 1))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc new file mode 100644 index 00000000..401b69e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 +[[[[[[(force (builtin chooseData)) + (con data (I 5))] + (lam x (con integer 1))] + (lam y (con string "two"))] + (lam z3 z3)] + (lam u (con data (I 4)))] + (lam v (con data (B #05)))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc.expected new file mode 100644 index 00000000..be1ce278 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataInteger/chooseDataInteger.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam u-0 (con data (I 4)))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc new file mode 100644 index 00000000..cd7c30ad --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 +[[[[[[(force (builtin chooseData)) + (con data (List [I 0, I 1 ]))] + (lam x (con integer 1))] + (lam y (con string "two"))] + (lam z3 z3)] + (lam u (con data (I 4)))] + (lam v (con data (B #05)))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc.expected new file mode 100644 index 00000000..f4eca644 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataList/chooseDataList.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam z3-0 z3-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc new file mode 100644 index 00000000..f870a2d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 +[[[[[[(force (builtin chooseData)) + (con data (Map [(I 0, B #00), (B #0F, I 1)]))] + (lam x (con integer 1))] + (lam y (con string "two"))] + (lam z3 z3)] + (lam u (con data (I 4)))] + (lam v (con data (B #05)))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc.expected new file mode 100644 index 00000000..df45a080 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseDataMap/chooseDataMap.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam y-0 (con string "two"))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc new file mode 100644 index 00000000..2270c44c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[[(force (force (builtin chooseList))) (con (list integer) [ 0 , 1 , 2 ])] (con integer 1)] (con integer 2)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-01/chooseList-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc new file mode 100644 index 00000000..d716e75d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[[(force (force (builtin chooseList))) (con (list integer) [ ])] (con integer 1)] (con integer 2)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-02/chooseList-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc new file mode 100644 index 00000000..f8071ce4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc @@ -0,0 +1,2 @@ +-- chooseList should accept arbitrary terms in the branches +(program 1.0.0 [[[(force (force (builtin chooseList))) (con (list integer) [ 0, 1, 2 ])] (lam x x)] (lam y (lam z z))]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc.expected new file mode 100644 index 00000000..7a1bae04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-03/chooseList-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam y-0 (lam z-1 z-1))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc new file mode 100644 index 00000000..99a92319 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc @@ -0,0 +1,2 @@ +-- chooseList should accept arbitrary terms in the branches +(program 1.0.0 [[[(force (force (builtin chooseList))) (con (list integer) [ ])] (lam x x)] (lam y (lam z z))]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc.expected new file mode 100644 index 00000000..4b120840 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseList/chooseList-04/chooseList-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 x-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc new file mode 100644 index 00000000..83665e6b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[(force (builtin chooseUnit)) (con unit ())] (con integer 2)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-01/chooseUnit-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc new file mode 100644 index 00000000..97394894 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc @@ -0,0 +1,2 @@ +-- chooseUnit should accept arbitrary terms for the second argument +(program 1.0.0 [[(force (builtin chooseUnit)) (con unit ())] (lam x x)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc.expected new file mode 100644 index 00000000..4b120840 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/chooseUnit/chooseUnit-02/chooseUnit-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 x-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc new file mode 100644 index 00000000..dbf74ec7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin complementByteString) (con bytestring #) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc new file mode 100644 index 00000000..af3cc158 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin complementByteString) (con bytestring #0f) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..b167c13d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc new file mode 100644 index 00000000..2ebebb9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin complementByteString) (con bytestring #b00b) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..708427a3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #4ff4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc new file mode 100644 index 00000000..790ac7c9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin complementByteString) + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..2cbc756c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-04/case-04.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #246379e3675c2e6346d73dd5cd5551f5b08bfeec23b78cb2c3ffe9a834702d46b68050e95bf3e1322829a7e4aa49daaac50c + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc new file mode 100644 index 00000000..3db789a3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc @@ -0,0 +1,18 @@ +(program 1.0.0 + [ + (lam x + [ + (builtin equalsByteString) + x + [ + (builtin complementByteString) + [ + (builtin complementByteString) + x + ] + ] + ] + ) + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/complementByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc new file mode 100644 index 00000000..b6c62414 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc @@ -0,0 +1,2 @@ +-- the arg overflow'ed over the maxBound :: Word8 +(program 1.0.0 [(builtin consByteString) (con integer 256) (con bytestring #)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-01/consByteString-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc new file mode 100644 index 00000000..ab20a4aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin consByteString) (con integer -88) (con bytestring #686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-02/consByteString-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc new file mode 100644 index 00000000..9855cea9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin consByteString) (con integer 84) (con bytestring #686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc.expected new file mode 100644 index 00000000..fba0ee4a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/consByteString/consByteString-03/consByteString-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #54686543616b654973414c6965)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc new file mode 100644 index 00000000..dd5dc6d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin constrData) + (con integer 7212) + ] + (con (list data) [B #79d3, List [I 44]]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc.expected new file mode 100644 index 00000000..c5a1bac6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/constrData/constrData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Constr 7212 [B #79d3, List [I 44]]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc new file mode 100644 index 00000000..c24a1732 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin countSetBits) (con bytestring #) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc new file mode 100644 index 00000000..668ff776 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin countSetBits) (con bytestring #0000) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc new file mode 100644 index 00000000..9ae4ccf3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin countSetBits) (con bytestring #0100) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc new file mode 100644 index 00000000..ba6e6204 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin countSetBits) (con bytestring #0001) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc new file mode 100644 index 00000000..e689512f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin countSetBits) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc.expected new file mode 100644 index 00000000..bc529829 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 163)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc new file mode 100644 index 00000000..bde85cf3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin countSetBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc new file mode 100644 index 00000000..29b75f09 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin countSetBits) + (con bytestring #00000000000000100000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc new file mode 100644 index 00000000..e639ce90 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin countSetBits) + (con bytestring #FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc.expected new file mode 100644 index 00000000..a48493b9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/countSetBits/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 344)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc new file mode 100644 index 00000000..9946d1b5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc @@ -0,0 +1,2 @@ +-- invalid utf8 +(program 1.0.0 [(builtin decodeUtf8) (con bytestring #A3)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-invalid/decodeUtf8-invalid.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc new file mode 100644 index 00000000..002bd626 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin decodeUtf8) (con bytestring #4f6c61)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc.expected new file mode 100644 index 00000000..0bbd3f0d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/decodeUtf8/decodeUtf8-ok/decodeUtf8-ok.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con string "Ola")) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc new file mode 100644 index 00000000..cb6e196d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin divideInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-01/divideInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc new file mode 100644 index 00000000..de9ea85b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer -503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-neg/divideInteger-neg-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc new file mode 100644 index 00000000..eb78c4db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer -503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-neg-pos/divideInteger-neg-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc new file mode 100644 index 00000000..21db5771 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer 503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-neg/divideInteger-pos-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc new file mode 100644 index 00000000..022b4a1a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer 503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-pos-pos/divideInteger-pos-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc new file mode 100644 index 00000000..7d470cd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer 1) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/divideInteger/divideInteger-zero/divideInteger-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc new file mode 100644 index 00000000..ce5c2f79 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc @@ -0,0 +1,7 @@ +-- Dropping zero elements has no effect. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 0) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc.expected new file mode 100644 index 00000000..6bd54c6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-01/dropList-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [11,22,33,44,55,66,77,88,99])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc new file mode 100644 index 00000000..2d0e44b9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc @@ -0,0 +1,18 @@ +-- Dropping zero elements has no effect. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 0) ] + (con (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc.expected new file mode 100644 index 00000000..c2287f25 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-02/dropList-02.uplc.expected @@ -0,0 +1,15 @@ +(program + 1.0.0 + (con + (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc new file mode 100644 index 00000000..d551fbe1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc @@ -0,0 +1,7 @@ +-- A typical case where you really drop some elements. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 7) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc.expected new file mode 100644 index 00000000..07ef5cfc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-03/dropList-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [88,99])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc new file mode 100644 index 00000000..c4787034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc @@ -0,0 +1,18 @@ +-- A typical case where you really drop some elements. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 7) ] + (con (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc.expected new file mode 100644 index 00000000..bb2a0a45 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-04/dropList-04.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con (list bytestring) [#89abcd93232479173417824fff, #ffeeffeeffee]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc new file mode 100644 index 00000000..43d9be28 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc @@ -0,0 +1,8 @@ +-- Dropping more elements than the length of the list succeeds and returns the +-- empty list. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 17) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-05/dropList-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc new file mode 100644 index 00000000..eeb49333 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc @@ -0,0 +1,19 @@ +-- Dropping more elements than the length of the list succeeds and returns the +-- empty list. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 17) ] + (con (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc.expected new file mode 100644 index 00000000..0dad60f6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-06/dropList-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list bytestring) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc new file mode 100644 index 00000000..ffae8658 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc @@ -0,0 +1,7 @@ +-- Dropping a negative number of elements succeeds and returns the list unchanged. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer -7) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc.expected new file mode 100644 index 00000000..6bd54c6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-07/dropList-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [11,22,33,44,55,66,77,88,99])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc new file mode 100644 index 00000000..d0ec0eef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc @@ -0,0 +1,18 @@ +-- Dropping a negative number of elements succeeds and returns the list unchanged. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer -7) ] + (con (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc.expected new file mode 100644 index 00000000..c2287f25 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-08/dropList-08.uplc.expected @@ -0,0 +1,15 @@ +(program + 1.0.0 + (con + (list bytestring) + [ #123456 + , #234567 + , #345678 + , #456789 + , #56789a + , #6789ab + , #789abc + , #89abcd93232479173417824fff + , #ffeeffeeffee ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc new file mode 100644 index 00000000..2d66d870 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc @@ -0,0 +1,10 @@ +-- This should return the empty list. However, if run in restricting mode it +-- will (probably, depending on the cost model) attempt to consume the maxmimum +-- budget and fail because the cost depends on how many elements you want to +-- drop, irrespective of the size of the list. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 10000000000000000000) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-09/dropList-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc new file mode 100644 index 00000000..5e13f1ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc @@ -0,0 +1,10 @@ +-- This should return the empty list. However, if run in restricting mode it +-- will (probably, depending on the cost model) attempt to consume the maxmimum +-- budget and fail because the cost depends on how many elements you want to +-- drop, irrespective of the size of the list. +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer -12345678901234567890) ] + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc.expected new file mode 100644 index 00000000..6bd54c6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-10/dropList-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [11,22,33,44,55,66,77,88,99])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc new file mode 100644 index 00000000..bb4e771b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc @@ -0,0 +1,8 @@ +-- Dropping any number of elements from an empty list always succeeds (and +-- returns the empty list). +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer -1234) ] + (con (list (pair bool string)) []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc.expected new file mode 100644 index 00000000..3b51fab7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-11/dropList-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (pair bool string)) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc new file mode 100644 index 00000000..6b7ab630 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc @@ -0,0 +1,8 @@ +-- Dropping any number of elements from an empty list always succeeds (and +-- returns the empty list). +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 0) ] + (con (list (pair unit integer)) []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc.expected new file mode 100644 index 00000000..356f5f58 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-12/dropList-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (pair unit integer)) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc new file mode 100644 index 00000000..3a66bbcc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc @@ -0,0 +1,8 @@ +-- Dropping any number of elements from an empty list always succeeds (and +-- returns the empty list). +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 1234) ] + (con (list (pair (list integer) unit)) []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc.expected new file mode 100644 index 00000000..0963b1af --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-13/dropList-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (pair (list integer) unit)) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc new file mode 100644 index 00000000..e6b635e9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc @@ -0,0 +1,19 @@ +-- Drop (maxBound::Int)-1 elements +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 9223372036854775806) ] + (con (list integer) + [ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 + , 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 + , 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 + , 50, 51, 52, 53, 54, 55, 56, 57, 58, 59 + , 60, 61, 62, 63, 64, 65, 66, 67, 68, 69 + , 70, 71, 72, 73, 74, 75, 76, 77, 78, 79 + , 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 + , 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 + , 100, 101, 102, 103, 104, 105, 106, 107 + , 108, 109, 110, 111 + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-14/dropList-14.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc new file mode 100644 index 00000000..b2ec7a04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc @@ -0,0 +1,19 @@ +-- Drop (maxBound::Int) elements +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 9223372036854775807) ] + (con (list integer) + [ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 + , 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 + , 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 + , 50, 51, 52, 53, 54, 55, 56, 57, 58, 59 + , 60, 61, 62, 63, 64, 65, 66, 67, 68, 69 + , 70, 71, 72, 73, 74, 75, 76, 77, 78, 79 + , 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 + , 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 + , 100, 101, 102, 103, 104, 105, 106, 107 + , 108, 109, 110, 111 + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-15/dropList-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc new file mode 100644 index 00000000..709c4685 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc @@ -0,0 +1,19 @@ +-- Drop (maxBound::Int)+1 elements +(program 1.0.0 + [ + [ (force (builtin dropList)) (con integer 9223372036854775808) ] + (con (list integer) + [ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 + , 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 + , 40, 41, 42, 43, 44, 45, 46, 47, 48, 49 + , 50, 51, 52, 53, 54, 55, 56, 57, 58, 59 + , 60, 61, 62, 63, 64, 65, 66, 67, 68, 69 + , 70, 71, 72, 73, 74, 75, 76, 77, 78, 79 + , 80, 81, 82, 83, 84, 85, 86, 87, 88, 89 + , 90, 91, 92, 93, 94, 95, 96, 97, 98, 99 + , 100, 101, 102, 103, 104, 105, 106, 107 + , 108, 109, 110, 111 + ] + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc.expected new file mode 100644 index 00000000..b72304e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/dropList/dropList-16/dropList-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc new file mode 100644 index 00000000..6197c568 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin encodeUtf8) (con string "Ola")]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc.expected new file mode 100644 index 00000000..c66651da --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/encodeUtf8/encodeUtf8.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #4f6c61)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc new file mode 100644 index 00000000..273c95dc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lengthOfByteString) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc.expected new file mode 100644 index 00000000..358b5def --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-01/equalsByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 13)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc new file mode 100644 index 00000000..8feae187 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin equalsByteString) (con bytestring #54686543616B654973414C6965) (con bytestring #54686543616B65497341506965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString-02/equalsByteString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc new file mode 100644 index 00000000..806ef68d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsByteString) (con bytestring #00ffaa) ] (con bytestring #00ffaa) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsByteString/equalsByteString/equalsByteString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc new file mode 100644 index 00000000..3435719d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin equalsData) + (con data (Constr 1 [I 0])) + ] + (con data (Constr 1 [I 0])) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-01/equalsData-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc new file mode 100644 index 00000000..692280c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin equalsData) + (con data (Constr 1 [I 0])) + ] + (con data (Constr 1 [I 1])) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-02/equalsData-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc new file mode 100644 index 00000000..6260d741 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin equalsData) + (con data (Constr 0 [I 0])) + ] + (con data (Constr 1 [I 0])) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-03/equalsData-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc new file mode 100644 index 00000000..3041852a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin equalsData) + (con data (Constr 17 [I 0])) + ] + (con data (Constr 17 [B #00])) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsData/equalsData-04/equalsData-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc new file mode 100644 index 00000000..b268648a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-01/equalsInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc new file mode 100644 index 00000000..208db892 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsInteger) (con integer 45723452347050234588234852993485827934) ] (con integer 45723452347050234588234852993485827933) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-02/equalsInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc new file mode 100644 index 00000000..946682ba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsInteger) (con integer 45723452347050234588234852993485827934) ] (con integer 45723452347050234588234852993485827934) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsInteger/equalsInteger-03/equalsInteger-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc new file mode 100644 index 00000000..b6f4933e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsString) (con string "Ola")] (con string " mundo!") ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-01/equalsString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc new file mode 100644 index 00000000..aec830df --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin equalsString) (con string "Ola")] (con string "Ola") ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/equalsString/equalsString-02/equalsString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc new file mode 100644 index 00000000..ec619715 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 2)] (con integer -3) ] (con integer -4)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-01/exp-neg-non-inverse-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc new file mode 100644 index 00000000..c063c86c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 500)] (con integer -5) ] (con integer 5)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/exp-neg-non-inverse-02/exp-neg-non-inverse-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc new file mode 100644 index 00000000..bafff0e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 500)] (con integer 0) ] (con integer 500)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-01/expMod-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc new file mode 100644 index 00000000..82d0936d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 500)] (con integer 5) ] (con integer 500)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-02/expMod-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc new file mode 100644 index 00000000..6c94ba7f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 1)] (con integer -3) ] (con integer 4)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-03/expMod-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc new file mode 100644 index 00000000..821e9540 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 2)] (con integer -3) ] (con integer 3)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-04/expMod-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc new file mode 100644 index 00000000..4b0b5f4f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 4)] (con integer -5) ] (con integer 9)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/expMod-05/expMod-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc new file mode 100644 index 00000000..aa50d6b3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc @@ -0,0 +1,8 @@ +-- m < 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 125) + (con integer -83241) + (con integer -7) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-01/expModInteger-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc new file mode 100644 index 00000000..41d245ea --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc @@ -0,0 +1,8 @@ +-- m < 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer -885) + (con integer 5000000) + (con integer -2) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-02/expModInteger-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc new file mode 100644 index 00000000..6060599d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc @@ -0,0 +1,8 @@ +-- m < 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 79123789) + (con integer 34767237) + (con integer -99572135136512635615235152) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-03/expModInteger-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc new file mode 100644 index 00000000..c9f238db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc @@ -0,0 +1,8 @@ +-- m = 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer -1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-04/expModInteger-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc new file mode 100644 index 00000000..2396ad21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc @@ -0,0 +1,8 @@ +-- m = 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-05/expModInteger-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc new file mode 100644 index 00000000..0908b277 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc @@ -0,0 +1,8 @@ +-- m = 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 5) + (con integer 12) + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-06/expModInteger-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc new file mode 100644 index 00000000..bae3e171 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc @@ -0,0 +1,8 @@ +-- m = 0 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 123234725734785273457322) + (con integer 321) + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-07/expModInteger-07.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc new file mode 100644 index 00000000..5c489468 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer 101) + (con integer 99) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-08/expModInteger-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc new file mode 100644 index 00000000..7cd88b0f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer 12389) + (con integer -9) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-09/expModInteger-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc new file mode 100644 index 00000000..c78a42cf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer -8987923471283646712347891237947623467284) + (con integer 0) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-10/expModInteger-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc new file mode 100644 index 00000000..b30b605f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 9) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-11/expModInteger-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc new file mode 100644 index 00000000..6cd9222f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer 9) + (con integer 0) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-12/expModInteger-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc new file mode 100644 index 00000000..663be45b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc @@ -0,0 +1,8 @@ +-- m = 1 -> return 0 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-13/expModInteger-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc new file mode 100644 index 00000000..ea25902c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc @@ -0,0 +1,8 @@ +-- m > 1 and e = 0 -> return 1 +(program 1.0.0 + [(builtin expModInteger) + (con integer -789) + (con integer 0) + (con integer 123) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-14/expModInteger-14.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc new file mode 100644 index 00000000..3e4d70e9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc @@ -0,0 +1,8 @@ +-- m > 1 and e = 0 -> return 1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 7) + (con integer 0) + (con integer 11) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-15/expModInteger-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc new file mode 100644 index 00000000..4cdc208e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc @@ -0,0 +1,8 @@ +-- m > 1 and e = 0 -> return 1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 6716724038975293475892345238945892345) + (con integer 0) + (con integer 11) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-16/expModInteger-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc new file mode 100644 index 00000000..71bdf865 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc @@ -0,0 +1,8 @@ +-- m > 1 and e = 0 -> return 1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 6716724038975293475892345238945892345) + (con integer 0) + (con integer 11000000000000000000000000000001200000000000000000000893) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-17/expModInteger-17.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc new file mode 100644 index 00000000..21ed565a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc @@ -0,0 +1,8 @@ +-- m > 1 and e = 0 -> return 1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer 2123478956273846578234523475237) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-18/expModInteger-18.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc new file mode 100644 index 00000000..9ea1017f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer 117) + (con integer 1) + (con integer 1000) + ] + [(builtin modInteger) + (con integer 117) + (con integer 1000) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-19/expModInteger-19.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc new file mode 100644 index 00000000..f7beffd1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer 4123213117) + (con integer 1) + (con integer 1000) + ] + [(builtin modInteger) + (con integer 4123213117) + (con integer 1000) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-20/expModInteger-20.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc new file mode 100644 index 00000000..e6c35b1a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer -883) + (con integer 1) + (con integer 1000) + ] + [(builtin modInteger) + (con integer -883) + (con integer 1000) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-21/expModInteger-21.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc new file mode 100644 index 00000000..6c481b5f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer -10000000000000000000000000883) + (con integer 1) + (con integer 1000) + ] + [(builtin modInteger) + (con integer -10000000000000000000000000883) + (con integer 1000) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-22/expModInteger-22.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc new file mode 100644 index 00000000..bb2672f8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer 0) + (con integer 1) + (con integer 123321) + ] + [(builtin modInteger) + (con integer 0) + (con integer 123321) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-23/expModInteger-23.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc new file mode 100644 index 00000000..530be83f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer 123321123321) + (con integer 1) + (con integer 123321) + ] + [(builtin modInteger) + (con integer 123321123321) + (con integer 123321) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-24/expModInteger-24.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc new file mode 100644 index 00000000..436ee166 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc @@ -0,0 +1,14 @@ +-- m > 1, e = 1 -> return b modulo m +(program 1.0.0 + [(builtin equalsInteger) + [(builtin expModInteger) + (con integer 71893478901378904789123789401789034781278399999) + (con integer 1) + (con integer 1789345724789527834523495789345) + ] + [(builtin modInteger) + (con integer 71893478901378904789123789401789034781278399999) + (con integer 1789345724789527834523495789345) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-25/expModInteger-25.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc new file mode 100644 index 00000000..137496ab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-26/expModInteger-26.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc new file mode 100644 index 00000000..2f4ff14e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 17) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-27/expModInteger-27.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc new file mode 100644 index 00000000..4ebf2d04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer -1717) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-28/expModInteger-28.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc new file mode 100644 index 00000000..09c210ed --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e = -1, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 3842610773) + (con integer -1) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-29/expModInteger-29.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc new file mode 100644 index 00000000..fba4cf29 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e = -1, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 16548071329) + (con integer -1) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-30/expModInteger-30.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc new file mode 100644 index 00000000..baf63470 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer -1134134121) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-31/expModInteger-31.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc new file mode 100644 index 00000000..d7dd4620 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 17) + (con integer -5) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-32/expModInteger-32.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc new file mode 100644 index 00000000..5a2a10fc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer -1717) + (con integer -1000000000000000000000000000000) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-33/expModInteger-33.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc new file mode 100644 index 00000000..56a29a38 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 3842610773) + (con integer -777777777777777777777771) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-34/expModInteger-34.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc new file mode 100644 index 00000000..89f11f00 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m > 1 -> fail +(program 1.0.0 + [(builtin expModInteger) + (con integer 16548071329) + (con integer -18446744073709551616) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-35/expModInteger-35.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc new file mode 100644 index 00000000..04236f9c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 1) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-36/expModInteger-36.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc new file mode 100644 index 00000000..080e32bf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 18) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-37/expModInteger-37.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc new file mode 100644 index 00000000..39b17e21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc @@ -0,0 +1,8 @@ +-- m > 1, e = -1, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer -1719) + (con integer -1) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc.expected new file mode 100644 index 00000000..535fe354 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-38/expModInteger-38.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 8)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc new file mode 100644 index 00000000..44d70a99 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e = -1, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 3842610771) + (con integer -1) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc.expected new file mode 100644 index 00000000..17ec64c0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-39/expModInteger-39.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 46828242895014337770)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc new file mode 100644 index 00000000..89716658 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e = -1, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 1654807132907) + (con integer -1) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc.expected new file mode 100644 index 00000000..99ba1f04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-40/expModInteger-40.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 36516505836773408443)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc new file mode 100644 index 00000000..cb5dadc2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 1) + (con integer -1134134121) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-41/expModInteger-41.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc new file mode 100644 index 00000000..08288c2f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 18) + (con integer -5) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-42/expModInteger-42.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc new file mode 100644 index 00000000..de24c0e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc @@ -0,0 +1,8 @@ +-- m > 1, e < 0, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer -1719) + (con integer -100000000000000000000000000000007) + (con integer 17) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc.expected new file mode 100644 index 00000000..3dfbdca1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-43/expModInteger-43.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 15)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc new file mode 100644 index 00000000..98ddc4de --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 3842610771) + (con integer -777777777777777777777771) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc.expected new file mode 100644 index 00000000..8bb021c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-44/expModInteger-44.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 57441510316368658593)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc new file mode 100644 index 00000000..854c0eb1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc @@ -0,0 +1,8 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m = 1 -> succeed +(program 1.0.0 + [(builtin expModInteger) + (con integer 1654807132907) + (con integer -18446744073709551616) + (con integer 63587797161187827317) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc.expected new file mode 100644 index 00000000..681f91ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-45/expModInteger-45.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 60415552098464659702)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc new file mode 100644 index 00000000..60c16a3f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc @@ -0,0 +1,20 @@ +-- m > 1, e = -1, gcd a m = 1 -> compute inverse +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 1) + (con integer -1) + (con integer 17) + ] + [(builtin expModInteger) + (con integer 1) + (con integer 1) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-46/expModInteger-46.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc new file mode 100644 index 00000000..0c857b60 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc @@ -0,0 +1,20 @@ +-- m > 1, e = -1, gcd a m = 1 -> compute inverse +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 18) + (con integer -1) + (con integer 17) + ] + [(builtin expModInteger) + (con integer 18) + (con integer 1) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-47/expModInteger-47.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc new file mode 100644 index 00000000..d1e31d49 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc @@ -0,0 +1,20 @@ +-- m > 1, e = -1, gcd a m = 1 -> compute inverse +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer -1719) + (con integer -1) + (con integer 17) + ] + [(builtin expModInteger) + (con integer -1719) + (con integer 1) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-48/expModInteger-48.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc new file mode 100644 index 00000000..0de8826d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc @@ -0,0 +1,20 @@ +-- m = 3842610773*16548071329, e = -1 gcd a m = 1 -> compute inverse +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 3842610771) + (con integer -1) + (con integer 63587797161187827317) + ] + [(builtin expModInteger) + (con integer 3842610771) + (con integer 1) + (con integer 63587797161187827317) + ] + ] + (con integer 63587797161187827317) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-49/expModInteger-49.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc new file mode 100644 index 00000000..2f14a9dd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc @@ -0,0 +1,20 @@ +-- m = 3842610773*16548071329, e = -1 gcd a m = 1 -> compute inverse +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 1654807132907) + (con integer -1) + (con integer 63587797161187827317) + ] + [(builtin expModInteger) + (con integer 1654807132907) + (con integer 1) + (con integer 63587797161187827317) + ] + ] + (con integer 63587797161187827317) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-50/expModInteger-50.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc new file mode 100644 index 00000000..9e48af53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc @@ -0,0 +1,20 @@ +-- m > 1, e < 0, gcd a m = 1 -> compute inverse power +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 1) + (con integer -1134134121) + (con integer 17) + ] + [(builtin expModInteger) + (con integer 1) + (con integer 1134134121) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-51/expModInteger-51.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc new file mode 100644 index 00000000..538980b6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc @@ -0,0 +1,20 @@ +-- m > 1, e < 0, gcd a m = 1 -> compute inverse power +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 18) + (con integer -5) + (con integer 17) + ] + [(builtin expModInteger) + (con integer 18) + (con integer 5) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-52/expModInteger-52.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc new file mode 100644 index 00000000..3768cde5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc @@ -0,0 +1,20 @@ +-- m > 1, e < 0, gcd a m = 1 -> compute inverse power +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer -1719) + (con integer -1000000000000000000000000000000) + (con integer 17) + ] + [(builtin expModInteger) + (con integer -1719) + (con integer 1000000000000000000000000000000) + (con integer 17) + ] + ] + (con integer 17) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-53/expModInteger-53.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc new file mode 100644 index 00000000..2b782269 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc @@ -0,0 +1,20 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m = 1 -> compute inverse power +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 3842610771) + (con integer -777777777777777777777771) + (con integer 63587797161187827317) + ] + [(builtin expModInteger) + (con integer 3842610771) + (con integer 777777777777777777777771) + (con integer 63587797161187827317) + ] + ] + (con integer 63587797161187827317) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-54/expModInteger-54.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc new file mode 100644 index 00000000..cb32f22b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc @@ -0,0 +1,20 @@ +-- m = 3842610773*16548071329, e < 0, gcd a m = 1 -> compute inverse power +(program 1.0.0 + [(builtin equalsInteger) + [(builtin modInteger) + [(builtin multiplyInteger) + [(builtin expModInteger) + (con integer 1654807132907) + (con integer -18446744073709551616) + (con integer 63587797161187827317) + ] + [(builtin expModInteger) + (con integer 1654807132907) + (con integer 18446744073709551616) + (con integer 63587797161187827317) + ] + ] + (con integer 63587797161187827317) + ] (con integer 1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-55/expModInteger-55.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc new file mode 100644 index 00000000..41ec36d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-56/expModInteger-56.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc new file mode 100644 index 00000000..75aa2671 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 2) + (con integer 64) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc.expected new file mode 100644 index 00000000..5f1f0a91 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-57/expModInteger-57.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 18446744073709551616)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc new file mode 100644 index 00000000..8031cded --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 2) + (con integer -64) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc.expected new file mode 100644 index 00000000..9dca14e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-58/expModInteger-58.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 30471602430872683006368077679533309455171990423147718600281005145357771866102 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc new file mode 100644 index 00000000..207d1e88 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 295783465278346578267348527836475862348589358937497) + (con integer 89734578923487957289347527893478952378945268423487234782378423) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc.expected new file mode 100644 index 00000000..10830250 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-59/expModInteger-59.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 32206691988103784342539609430659656895837532833998353585585601025665197189770 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc new file mode 100644 index 00000000..06442fa7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer -278903489723894263784627895384582367892349236727346) + (con integer 2782346783647862783469234789237848236498238946918723789178293) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc.expected new file mode 100644 index 00000000..a1f632d2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-60/expModInteger-60.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 41639481880816845111909653885891797604671528343369469127307248315308458868975 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc new file mode 100644 index 00000000..4456ed74 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 11111111111111111111111111111111111111111111111111111111111111111789427389478923) + (con integer -789239427389489234897829734789283974892734897283974897238947234722234) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc.expected new file mode 100644 index 00000000..576c5a61 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-61/expModInteger-61.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 9490012894827172785774821291029803814876173214515365770785362878234508261242 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc new file mode 100644 index 00000000..22fbca80 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer -11111111111111111111111111111111111111111111111111111111111111111789427389478923) + (con integer -789239427389489234897829734789283974892734897283974897238947234722234) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc.expected new file mode 100644 index 00000000..576c5a61 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-62/expModInteger-62.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 9490012894827172785774821291029803814876173214515365770785362878234508261242 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc new file mode 100644 index 00000000..a6f228f3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19, e = m-1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0289342903489028349034589023745823457892346934785623452334786341567142314) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819948) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-63/expModInteger-63.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc new file mode 100644 index 00000000..01393a7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19, e = -(m-1) +(program 1.0.0 + [(builtin expModInteger) + (con integer 99999999999999999999999999999999999999999999999999999999999999999999999999999999999) + (con integer -57896044618658097711785492504343953926634992332820282019728792003956564819948) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-64/expModInteger-64.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc new file mode 100644 index 00000000..70a3ff75 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19, e = 10000*(m-1) +(program 1.0.0 + [(builtin expModInteger) + (con integer 0289342903489028349034589023745823457892346934785623452334786341567142314) + (con integer 578960446186580977117854925043439539266349923328202820197287920039565648199480000) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-65/expModInteger-65.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc new file mode 100644 index 00000000..e0066e85 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 2^255-19, e = -10000*(m-1) +(program 1.0.0 + [(builtin expModInteger) + (con integer 99999999999999999999999999999999999999999999999999999999999999999999999999999999999) + (con integer -578960446186580977117854925043439539266349923328202820197287920039565648199480000) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-66/expModInteger-66.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc new file mode 100644 index 00000000..5514c860 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer 0) + (con integer 0) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-67/expModInteger-67.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc new file mode 100644 index 00000000..95b6942b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer 2) + (con integer 64) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc.expected new file mode 100644 index 00000000..5f1f0a91 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-68/expModInteger-68.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 18446744073709551616)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc new file mode 100644 index 00000000..2782bbc1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! -> fail (gcd > 1) +(program 1.0.0 + [(builtin expModInteger) + (con integer 2) + (con integer -64) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-69/expModInteger-69.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc new file mode 100644 index 00000000..7b8de054 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer 295783465278346578267348527836475862348589358937497) + (con integer 89734578923487957289347527893478952378945268423487234782378423) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc.expected new file mode 100644 index 00000000..38a6de21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-70/expModInteger-70.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 280175799933420074585178470510090012806707950340412289432212739835789837904455835552327022379259130346551828535037673 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc new file mode 100644 index 00000000..8a9fdd30 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer -278903489723894263784627895384582367892349236727346) + (con integer 2782346783647862783469234789237848236498238946918723789178293) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc.expected new file mode 100644 index 00000000..21a4e92d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-71/expModInteger-71.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 676608236808522252873008336960453539807071928324507727553824692454236867626155713650291062437090100975669387894718464 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc new file mode 100644 index 00000000..e656440a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer 11111111111111111111111111111111111111111111111111111111111111111789427389478923) + (con integer -789239427389489234897829734789283974892734897283974897238947234722234) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc.expected new file mode 100644 index 00000000..6c891e01 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-72/expModInteger-72.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 226253110172970512032322077499046610917698223745805046643293407253856550947890147970889384902312109044059858650440489 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc new file mode 100644 index 00000000..6e391290 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79! +(program 1.0.0 + [(builtin expModInteger) + (con integer -11111111111111111111111111111111111111111111111111111111111111111789427389478923) + (con integer -789239427389489234897829734789283974892734897283974897238947234722234) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc.expected new file mode 100644 index 00000000..6c891e01 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-73/expModInteger-73.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 226253110172970512032322077499046610917698223745805046643293407253856550947890147970889384902312109044059858650440489 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc new file mode 100644 index 00000000..ca9fe950 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79!, e = m-1 +(program 1.0.0 + [(builtin expModInteger) + (con integer 0289342903489028349034589023745823457892346934785623452334786341567142314) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010175999999999999999999) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc.expected new file mode 100644 index 00000000..591c9dcc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-74/expModInteger-74.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 799213302676025590986559862430737311371208606877556070099461944686298161515921765132026310527039911779485954640707584 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc new file mode 100644 index 00000000..f2db7f16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79!, e = -(m-1), a = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + (con integer -894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010175999999999999999999) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc.expected new file mode 100644 index 00000000..e31d6114 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-75/expModInteger-75.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 57896044618658097711785492504343953926634992332820282019728792003956564819949 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc new file mode 100644 index 00000000..00197105 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79!, e = 10000*(m-1) +(program 1.0.0 + [(builtin expModInteger) + (con integer 0289342903489028349034589023745823457892346934785623452334786341567142314) + (con integer 8946182130782975286851441715398316520698082167795719072138680632278379906935018605333618108410101759999999999999999990000) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc.expected new file mode 100644 index 00000000..5904d302 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-76/expModInteger-76.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 126589639180843360572550169437466175160404232405174811173487450267795410776435354182712112924966658652508478689509376 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc new file mode 100644 index 00000000..425fae28 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc @@ -0,0 +1,8 @@ +-- Large inputs: m = 79!, e = -10000*(m-1), a = 2^255-19 +(program 1.0.0 + [(builtin expModInteger) + (con integer 57896044618658097711785492504343953926634992332820282019728792003956564819949) + (con integer -8946182130782975286851441715398316520698082167795719072138680632278379906935018605333618108410101759999999999999999990000) + (con integer 894618213078297528685144171539831652069808216779571907213868063227837990693501860533361810841010176000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc.expected new file mode 100644 index 00000000..5f9235bc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/extra/expModInteger-77/expModInteger-77.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + integer + 267938415452876215619736915735930925390188109664796165617656900154039538886782993138509072889964389462027704913000001 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc new file mode 100644 index 00000000..5820f4d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 1)] (con integer 1) ] (con integer -3)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-neg/mod-neg.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc new file mode 100644 index 00000000..ff1b07c2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin expModInteger) (con integer 1)] (con integer 1) ] (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/expModInteger/mod-zero/mod-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc new file mode 100644 index 00000000..171a565f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin findFirstSetBit) (con bytestring #) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc new file mode 100644 index 00000000..a8c1146d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin findFirstSetBit) (con bytestring #0000) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc new file mode 100644 index 00000000..d5d079e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin findFirstSetBit) (con bytestring #0002) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc new file mode 100644 index 00000000..aedd25d7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin findFirstSetBit) (con bytestring #fff2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc new file mode 100644 index 00000000..de597456 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin findFirstSetBit) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc new file mode 100644 index 00000000..1be057cd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ + (builtin findFirstSetBit) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000001) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc new file mode 100644 index 00000000..63eeb492 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc @@ -0,0 +1,7 @@ +-- This returns 20, but should return 340 +(program 1.0.0 + [ + (builtin findFirstSetBit) + (con bytestring #50000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc.expected new file mode 100644 index 00000000..0a84b671 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/findFirstSetBit/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 340)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc new file mode 100644 index 00000000..95a74dc0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(force (force (builtin fstPair))) + (con (pair bool bytestring) + (True, #012345))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/fstPair/fstPair.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc new file mode 100644 index 00000000..180a9a3e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin headList)) (con (list integer) [ 1, 2 ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-01/headList-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc new file mode 100644 index 00000000..5858ea04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin headList)) (con (list integer) [ ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-02/headList-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc new file mode 100644 index 00000000..e7c38b55 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin headList)) (con (list integer) [ 1, 2, 3 ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headList-03/headList-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc new file mode 100644 index 00000000..e7c3b1b3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc @@ -0,0 +1,2 @@ +-- head is partial like haskell's and blows up when given an empty list +(program 1.0.0 [(force (builtin headList)) [(builtin mkNilData) (con unit ())]]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/headList/headPartial/headPartial.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc new file mode 100644 index 00000000..a064baf2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin iData) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc.expected new file mode 100644 index 00000000..b8541bf5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/iData/iData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (I 0))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc new file mode 100644 index 00000000..94a11f44 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (force (builtin ifThenElse)) (con bool True) ] (lam x x) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc.expected new file mode 100644 index 00000000..4b120840 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-01/ifThenElse-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 x-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc new file mode 100644 index 00000000..4cd3b1bf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(force (builtin ifThenElse)) (con bool False) (lam x x) (lam y (lam z z))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc.expected new file mode 100644 index 00000000..7a1bae04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-02/ifThenElse-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam y-0 (lam z-1 z-1))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc new file mode 100644 index 00000000..4f44fc88 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(force (builtin ifThenElse)) (con bool False) (lam x x) (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc.expected new file mode 100644 index 00000000..864f897c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-03/ifThenElse-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc new file mode 100644 index 00000000..62e28438 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(force (builtin ifThenElse)) (con bool False) (error) (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-04/ifThenElse-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc new file mode 100644 index 00000000..2b3b895e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (force (builtin ifThenElse)) (con integer 1) ] (con integer 11) ] (con integer -22) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-01/ifThenElse-bad-cond-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc new file mode 100644 index 00000000..239ccef4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (force (builtin ifThenElse)) (lam x (lam y x)) ] (con integer 11) ] (con integer -22) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-bad-cond-02/ifThenElse-bad-cond-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc new file mode 100644 index 00000000..c203306d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ [ (builtin ifThenElse) (con bool True) ] (con integer 0) ] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ifThenElse/ifThenElse-no-force/ifThenElse-no-force.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc new file mode 100644 index 00000000..64d1090b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc @@ -0,0 +1,11 @@ +-- Taking an array element by index +(program 1.1.0 + [ + [ + (force (builtin indexArray)) + (con (array integer) [1, 2, 3, 4, 5]) + ] + (con integer 1) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc.expected new file mode 100644 index 00000000..2b513f80 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-01/indexArray-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc new file mode 100644 index 00000000..da0c8aa1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc @@ -0,0 +1,10 @@ +-- Taking an array element by index which is out of bounds +(program 1.1.0 + [ + [ + (force (builtin indexArray)) + (con (array integer) [1, 2, 3, 4, 5]) + ] + (con integer 5) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-02/indexArray-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc new file mode 100644 index 00000000..ce1b63ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc @@ -0,0 +1,10 @@ +-- Taking an array element by a negative index +(program 1.1.0 + [ + [ + (force (builtin indexArray)) + (con (array integer) [1, 2, 3, 4, 5]) + ] + (con integer -1) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexArray/indexArray-03/indexArray-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc new file mode 100644 index 00000000..6f1dbcb3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin indexByteString) (con bytestring #00ffaa) ] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc.expected new file mode 100644 index 00000000..369465fd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteString-01/indexByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 255)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc new file mode 100644 index 00000000..340218bb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin indexByteString) (con bytestring #00) (con integer 1)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOOB/indexByteStringOOB.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc new file mode 100644 index 00000000..07c07c92 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc @@ -0,0 +1,3 @@ +-- this is different than out-of-bounds error, the index argument overflow'ed the maxBound :: Int64 +-- same error would happen when underflow'ing the minBound :: Int64 +(program 1.0.0 [(builtin indexByteString) (con bytestring #00) (con integer 9223372036854775808)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/indexByteString/indexByteStringOverflow/indexByteStringOverflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc new file mode 100644 index 00000000..ae354c2b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc @@ -0,0 +1,9 @@ +-- A key larger than 32-bit, which is not allowed +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) + (con bytestring #) + (con integer 1) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-1/key-too-long-1.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc new file mode 100644 index 00000000..3ac17c67 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc @@ -0,0 +1,9 @@ +-- A key larger than 32-bit, which is not allowed +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #) + (con bytestring #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) + (con integer 1) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/key-too-long-2/key-too-long-2.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc new file mode 100644 index 00000000..60063b9e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc @@ -0,0 +1,9 @@ +-- A key larger than 32-bit, which is only allowed when inserting 0 value +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) + (con bytestring #) + (con integer 0) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc.expected new file mode 100644 index 00000000..bbf3c399 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-1/long-key-zero-1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc new file mode 100644 index 00000000..52a6dd21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc @@ -0,0 +1,9 @@ +-- A key larger than 32-bit, which is only allowed when inserting 0 value +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #) + (con bytestring #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) + (con integer 0) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc.expected new file mode 100644 index 00000000..bbf3c399 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/long-key-zero-2/long-key-zero-2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc new file mode 100644 index 00000000..d0065668 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #00) + (con bytestring #00) + (con integer 1) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc.expected new file mode 100644 index 00000000..e9f92199 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-empty/multi-ccy-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)]), (#00, [(#00, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc new file mode 100644 index 00000000..dbe18ca9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #aa) + (con bytestring #aa) + (con integer 5) + (con value [(#aa, [(#aa, 1)]), (#bb, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc.expected new file mode 100644 index 00000000..f96f4511 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-ccy-nonempty/multi-ccy-nonempty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 5)]), (#bb, [(#aa, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc new file mode 100644 index 00000000..a34e1141 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #aa) + (con bytestring #bb) + (con integer 10) + (con value [(#aa, [(#aa, 5), (#bb, 15), (#cc, 20)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc.expected new file mode 100644 index 00000000..b88a45b4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/multi-token/multi-token.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 5), (#bb, 10), (#cc, 20)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc new file mode 100644 index 00000000..720456e3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer -1) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc.expected new file mode 100644 index 00000000..f1a03ed3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/negative-empty/negative-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, -1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc new file mode 100644 index 00000000..2ce5f686 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc @@ -0,0 +1,10 @@ +-- Inserts 2^17 - 1, which is the maximum allowed value for a token +(program 1.0.0 + [ + (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer 170141183460469231731687303715884105727) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc.expected new file mode 100644 index 00000000..abedd914 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-overflow/no-overflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#, [(#, 170141183460469231731687303715884105727)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc new file mode 100644 index 00000000..678fbcac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc @@ -0,0 +1,10 @@ +-- Inserts -2^127, which is the minimum allowed value of a token +(program 1.0.0 + [ + (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer -170141183460469231731687303715884105728) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc.expected new file mode 100644 index 00000000..2ae965e9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/no-underflow/no-underflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#, [(#, -170141183460469231731687303715884105728)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc new file mode 100644 index 00000000..967b4922 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc @@ -0,0 +1,10 @@ +-- Inserts 2^127, which exceeds the maximum value of a token +(program 1.0.0 + [ + (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer 170141183460469231731687303715884105728) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/overflow/overflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc new file mode 100644 index 00000000..06dc4ad8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer 1) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc.expected new file mode 100644 index 00000000..bbf3c399 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-empty/positive-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc new file mode 100644 index 00000000..4f5677b8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer 1) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc.expected new file mode 100644 index 00000000..bbf3c399 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/positive-nonempty/positive-nonempty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc new file mode 100644 index 00000000..53adf4d9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc @@ -0,0 +1,10 @@ +-- Inserts -2^127 - 1, which exceeds the minimum allowed value of a token +(program 1.0.0 + [ + (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer -170141183460469231731687303715884105729) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/underflow/underflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc new file mode 100644 index 00000000..b617257e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + (builtin insertCoin) + (con bytestring #) + (con bytestring #) + (con integer 0) + (con value [(#, [(#, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/insertCoin/zero-positive/zero-positive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc new file mode 100644 index 00000000..ff2ebfae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc @@ -0,0 +1,4 @@ +-- Check that a particular integer encodes to the expected bytestring using exactly the right width. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 6) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected new file mode 100644 index 00000000..64975874 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #123456abcdef)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc new file mode 100644 index 00000000..a2b5144a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc @@ -0,0 +1,5 @@ +-- Check that a particular integer encodes to the expected bytestring with some +-- extra padding on the left when the width is greater than the minimal required width +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 12) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected new file mode 100644 index 00000000..8d51fa18 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #000000000000123456abcdef)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc new file mode 100644 index 00000000..2f6b805c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) fits into the maximum width. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 8192) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156735) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected new file mode 100644 index 00000000..d55150f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc new file mode 100644 index 00000000..cd5880c9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) isn't accepted if the width is too small. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 8191) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156731) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc new file mode 100644 index 00000000..6a62db89 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc @@ -0,0 +1,5 @@ +-- Check that one more than the maximum allowable input (ie, 2^65536) doesn't fit into the maximum width. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 8192) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156736) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc new file mode 100644 index 00000000..abe3367a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc @@ -0,0 +1,4 @@ +-- Check that we can encode zero using the maximum width (8192). +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 8192) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected new file mode 100644 index 00000000..2dda4edd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc new file mode 100644 index 00000000..83c02e59 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc @@ -0,0 +1,4 @@ +-- Negative inputs give an error +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 20) (con integer -5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-input/negative-input.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc new file mode 100644 index 00000000..5e81bc95 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc @@ -0,0 +1,4 @@ +-- Negative widths give an error +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer -20) (con integer 5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/negative-width/negative-width.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc new file mode 100644 index 00000000..49cfa2b2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc @@ -0,0 +1,4 @@ +-- Check that trying to encode an integer to a bytestring using too narrow a width fails. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 5) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/too-narrow/too-narrow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc new file mode 100644 index 00000000..f7cfd3e4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc @@ -0,0 +1,4 @@ +-- Check that a width greater than the maximum of 8192 is rejected when encoding zero. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 8193) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc new file mode 100644 index 00000000..d79f279e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc @@ -0,0 +1,4 @@ +-- Zero should encode to a bytestring consisting entirely of zero bytes. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 12) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc.expected new file mode 100644 index 00000000..5a52e826 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/bounded/zero/zero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #000000000000000000000000)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc new file mode 100644 index 00000000..c84f0091 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc @@ -0,0 +1,4 @@ +-- Check that a particular integer encodes to the expected bytestring +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 0) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc.expected new file mode 100644 index 00000000..64975874 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/correct-output/correct-output.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #123456abcdef)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc new file mode 100644 index 00000000..28143160 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc @@ -0,0 +1,5 @@ +-- Check that one more than the maximum allowable input (ie, 2^65536) is rejected. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 0) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156736) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/input-too-big/input-too-big.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc new file mode 100644 index 00000000..5432faab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) is accepted. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 0) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156735) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc.expected new file mode 100644 index 00000000..d55150f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/maximum-input/maximum-input.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc new file mode 100644 index 00000000..a199c17a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc @@ -0,0 +1,4 @@ +-- Negative inputs cause an error. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 0) (con integer -5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/negative-input/negative-input.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc new file mode 100644 index 00000000..bb99de06 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc @@ -0,0 +1,4 @@ +-- Zero should encode to the empty bytestring. +(program 1.0.0 + [(builtin integerToByteString) (con bool True) (con integer 0) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/big-endian/unbounded/zero/zero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc new file mode 100644 index 00000000..01152010 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc @@ -0,0 +1,4 @@ +-- Check that a particular integer encodes to the expected bytestring using exactly the right width. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 6) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected new file mode 100644 index 00000000..25ccda53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-exact-width/correct-output-exact-width.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #efcdab563412)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc new file mode 100644 index 00000000..f0919757 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc @@ -0,0 +1,6 @@ +-- Check that a particular integer encodes to the expected bytestring with some +-- extra padding on the right when the width is greater than the minimal +-- required width. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 12) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected new file mode 100644 index 00000000..3751f533 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/correct-output-extra-width/correct-output-extra-width.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #efcdab563412000000000000)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc new file mode 100644 index 00000000..230bdbe1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) fits into the maximum width. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 8192) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156735) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected new file mode 100644 index 00000000..d55150f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-fits-max-width/max-input-fits-max-width.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc new file mode 100644 index 00000000..9dd4b371 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) isn't accepted if the width is too small. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 8191) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156735) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-input-width-too-small/max-input-width-too-small.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc new file mode 100644 index 00000000..ec462425 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc @@ -0,0 +1,5 @@ +-- Check that one more than the maximum allowable input (ie, 2^65536) doesn't fit into the maximum width. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 8192) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156736) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/max-width-input-too-big/max-width-input-too-big.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc new file mode 100644 index 00000000..b7440918 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc @@ -0,0 +1,4 @@ +-- Check that we can encode zero using the maximum width (8192). +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 8192) (con integer 0)] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected new file mode 100644 index 00000000..2dda4edd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/maximum-width-zero/maximum-width-zero.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc new file mode 100644 index 00000000..86f1597a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc @@ -0,0 +1,4 @@ +-- Negative inputs give an error +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 20) (con integer -5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-input/negative-input.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc new file mode 100644 index 00000000..080dffa6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc @@ -0,0 +1,4 @@ +-- Negative widths give an error +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer -20) (con integer 5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/negative-width/negative-width.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc new file mode 100644 index 00000000..31568f7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc @@ -0,0 +1,4 @@ +-- Check that trying to encode an integer to a bytestring using too narrow a width fails. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 5) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/too-narrow/too-narrow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc new file mode 100644 index 00000000..f7e32da6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc @@ -0,0 +1,4 @@ +-- Check that a width greater than the maximum of 8192 is rejected when encoding zero. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 8193) (con integer 0)] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/width-too-big-zero/width-too-big-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc new file mode 100644 index 00000000..741f7964 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc @@ -0,0 +1,4 @@ +-- Zero should encode to a bytestring consisting entirely of zero bytes. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 12) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc.expected new file mode 100644 index 00000000..5a52e826 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/bounded/zero/zero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #000000000000000000000000)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc new file mode 100644 index 00000000..a3455e2c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc @@ -0,0 +1,4 @@ +-- Check that a particular integer encodes to the expected bytestring. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 0) (con integer 20016001699311)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc.expected new file mode 100644 index 00000000..25ccda53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/correct-output/correct-output.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #efcdab563412)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc new file mode 100644 index 00000000..f6851a21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc @@ -0,0 +1,5 @@ +-- Check that one more than the maximum allowable input (ie, 2^65536) is rejected. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 0) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156736) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/input-too-big/input-too-big.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc new file mode 100644 index 00000000..c08f0f03 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc @@ -0,0 +1,5 @@ +-- Check that the maximum allowable input (2^65536-1) is accepted. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 0) (con integer 2003529930406846464979072351560255750447825475569751419265016973710894059556311453089506130880933348101038234342907263181822949382118812668869506364761547029165041871916351587966347219442930927982084309104855990570159318959639524863372367203002916969592156108764948889254090805911457037675208500206671563702366126359747144807111774815880914135742720967190151836282560618091458852699826141425030123391108273603843767876449043205960379124490905707560314035076162562476031863793126484703743782954975613770981604614413308692118102485959152380195331030292162800160568670105651646750568038741529463842244845292537361442533614373729088303794601274724958414864915930647252015155693922628180691650796381064132275307267143998158508811292628901134237782705567421080070065283963322155077831214288551675554073345107213112427399562982719769150054883905223804357045848197956393157853510018992000024141963706813559840464039472194016069517690156119726982337890017641517190051133466306898140219383481435426387306539552969691388024158161859561100640362119796101859534802787167200122604642492385111393400464351623867567078745259464670903886547743483217897012764455529409092021959585751622973333576159552394885297579954028471943529913543763705986928913757153740001986394332464890052543106629669165243419174691389632476560289415199775477703138064781342309596190960654591300890188887588084733625956065444888501447335706058817090162108499714529568344061979690565469813631162053579369791403236328496233046421066136200220175787851857409162050489711781820400187282939943446186224328009837323764931814789848119452713007440220765680910376203999203492023906626264491909167985461515778839060397720759279378852241294301017458086862263369284725851403039615558564330385450688652213114813638408384778263790459607186876728509763471271988890680478243230394718650525660978150729861141430305816927924971409161059417185352275887504477592218301158780701975535722241400019548102005661773589781499532325208589753463547007786690406429016763808161740550405117670093673202804549339027992491867306539931640720492238474815280619166900933805732120816350707634351669869625020969023162859350071874190579161241536897514808261904847946571736601005892476655445840838334790544144817684255327207315586349347605137419779525190365032198020108764738368682531025183377533908861426184800374008082238104076468878471647552945326947661700424461063311238021134588694532200116564076327023074292426051582811070387018345324567635625951430032037432740780879056283663406965030844225855967039271869461158513793386475699748568670079823960604393478850861649260304945061743412365828352144806726676841807083754862211408236579802961200027441324438432402331257403545019352428776430880232850855886089962774458164680857875115807014743763867976955049991643998284357290415378143438847303484261903388841494031366139854257635577105335580206622185577060082551288893332226436281984838613239570676191409638533832374343758830859233722284644287996245605476932428998432652677378373173288063210753211238680604674708428051166488709084770291208161104912555598322366244868556651402684641209694982590565519216188104341226838996283071654868525536914850299539675503954938371853405900096187489473992880432496373165753803673586710175783994818471798498246948060532081996066183434012476096639519778021441199752546704080608499344178256285092726523709898651539462193004607364507926212975917698293892367015170992091531567814439791248475706237804600009918293321306880570046591458387208088016887445835557926258465124763087148566313528934166117490617526671492672176128330845273936469244582892571388877839056300482483799839692029222215486145902373478222682521639957440801727144146179559226175083889020074169926238300282286249284182671243405751424188569994272331606998712986882771820617214453142574944015066139463169197629181506579745526236191224848063890033669074365989226349564114665503062965960199720636202603521917776740668777463549375318899587866282125469797102065747232721372918144666659421872003474508942830911535189271114287108376159222380276605327823351661555149369375778466670145717971901227117812780450240026384758788339396817962950690798817121690686929538248529830023476068454114178139110648560236549754227497231007615131870024053910510913817843721791422528587432098524957878034683703337818421444017138688124249984418618129271198533315382567321870421530631197748535214670955334626336610864667332292409879849256691109516143618601548909740241913509623043612196128165950518666022030715613684732364660868905014263913906515063908199378852318365059897299125404479443425166774299659811849233151555272883274028352688442408752811283289980625912673699546247341543333500147231430612750390307397135252069338173843322950701049061867539433130784798015655130384758155685236218010419650255596181934986315913233036096461905990236112681196023441843363334594927631946101716652913823717182394299216272538461776065694542297877071383198817036964588689811863210976900355735884624464835706291453052757101278872027965364479724025405448132748391794128826423835171949197209797145936887537198729130831738033911016128547415377377715951728084111627597186384924222802373441925469991983672192131287035585307966942713416391033882754318613643490100943197409047331014476299861725424423355612237435715825933382804986243892498222780715951762757847109475119033482241412025182688713728193104253478196128440176479531505057110722974314569915223451643121848657575786528197564843508958384722923534559464521215831657751471298708225909292655638836651120681943836904116252668710044560243704200663709001941185557160472044643696932850060046928140507119069261393993902735534545567470314903886022024639948260501762431969305640666366626090207048887438898907498152865444381862917382901051820869936382661868303915273264581286782806601337500096593364625146091723180312930347877421234679118454791311109897794648216922505629399956793483801699157439700537542134485874586856047286751065423341893839099110586465595113646061055156838541217459801807133163612573079611168343863767667307354583494789788316330129240800836356825939157113130978030516441716682518346573675934198084958947940983292500086389778563494693212473426103062713745077286156922596628573857905533240641849018451328284632709269753830867308409142247659474439973348130810986399417379789657010687026734161967196591599588537834822988270125605842365589539690306474965584147981310997157542043256395776070485100881578291408250777738559790129129407309462785944505859412273194812753225152324801503466519048228961406646890305102510916237770448486230229488966711380555607956620732449373374027836767300203011615227008921843515652121379215748206859356920790214502277133099987729459596952817044582181956080965811702798062669891205061560742325686842271306295009864421853470810407128917646906550836129916694778023822502789667843489199409657361704586786242554006942516693979292624714524945408858422726153755260071904336329196375777502176005195800693847635789586878489536872122898557806826518192703632099480155874455575175312736471421295536494084385586615208012115079075068553344489258693283859653013272046970694571546959353658571788894862333292465202735853188533370948455403336565356988172582528918056635488363743793348411845580168331827676834646291995605513470039147876808640322629616641560667508153710646723108461964247537490553744805318226002710216400980584497526023035640038083472053149941172965736785066421400842696497103241919182121213206939769143923368374709228267738708132236680086924703491586840991153098315412063566123187504305467536983230827966457417620806593177265685841681837966106144963432544111706941700222657817358351259821080769101961052229263879745049019254311900620561906577452416191913187533984049343976823310298465893318373015809592522829206820862230332585280119266496314441316442773003237792274712330696417149945532261035475145631290668854345426869788447742981777493710117614651624183616680254815296335308490849943006763654806102940094693750609845588558043970485914449584445079978497045583550685408745163316464118083123079704389849190506587586425810738422420591191941674182490452700288263983057950057341711487031187142834184499153456702915280104485145176055306971441761368582384102787659324662689978418319620312262421177391477208004883578333569204533935953254564897028558589735505751235129536540502842081022785248776603574246366673148680279486052445782673626230852978265057114624846595914210278122788941448163994973881884622768244851622051817076722169863265701654316919742651230041757329904473537672536845792754365412826553581858046840069367718605020070547247548400805530424951854495267247261347318174742180078574693465447136036975884118029408039616746946288540679172138601225419503819704538417268006398820656328792839582708510919958839448297775647152026132871089526163417707151642899487953564854553553148754978134009964854498635824847690590033116961303766127923464323129706628411307427046202032013368350385425360313636763575212604707425311209233402837482949453104727418969287275572027615272268283376741393425652653283068469997597097750005560889932685025049212884068274139881631540456490350775871680074055685724021758685439053228133770707415830756269628316955687424060527726485853050611356384851965918968649596335568216975437621430778665934730450164822432964891270709898076676625671517269062058815549666382573829274182082278960684488222983394816670984039024283514306813767253460126007269262969468672750794346190439996618979611928750519442356402644303271737341591281496056168353988188569484045342311424613559925272330064881627466723523751234311893442118885085079358163848994487544756331689213869675574302737953785262542329024881047181939037220666894702204258836895840939998453560948869946833852579675161882159410981624918741813364726965123980677561947912557957446471427868624053750576104204267149366084980238274680575982591331006919941904651906531171908926077949119217946407355129633864523035673345588033313197080365457184791550432654899559705862888286866606618021882248602144999973122164138170653480175510438406624412822803616648904257377640956326482825258407669045608439490325290526337532316509087681336614242398309530806549661879381949120033919489494065132398816642080088395554942237096734840072642705701165089075196155370186264797456381187856175457113400473810762763014953309735174180655479112660938034311378532532883533352024934365979129341284854970946826329075830193072665337782559314331110963848053940859283988907796210479847919686876539987477095912788727475874439806779824968278272200926449944559380414608770641941810440758269805688038949654616587983904660587645341810289907194293021774519976104495043196841503455514044820928933378657363052830619990077748726922998608279053171691876578860908941817057993404890218441559791092676862796597583952483926734883634745651687016166240642424241228961118010615682342539392180052483454723779219911228595914191877491793823340010078128326506710281781396029120914720100947878752551263372884222353869490067927664511634758101193875319657242121476038284774774571704578610417385747911301908583877890152334343013005282797038580359815182929600305682612091950943737325454171056383887047528950563961029843641360935641632589408137981511693338619797339821670761004607980096016024823096943043806956620123213650140549586250615282588033022908385812478469315720323233601899469437647726721879376826431828382603564520699468630216048874528424363593558622333506235945002890558581611275341783750455936126130852640828051213873177490200249552738734585956405160830583053770732533971552620444705429573538361113677523169972740292941674204423248113875075631319078272188864053374694213842169928862940479635305150560788126366206497231257579019598873041195626227343728900516561111094111745277965482790471250581999077498063821559376885546498822938985408291325129076478386322494781016753491693489288104203015610283386143827378160946341335383578340765314321417150655877547820252454780657301342277470616744241968952613164274104695474621483756288299771804186785084546965619150908695874251184435837306590951460980451247409411373899927822492983367796011015387096129749705566301637307202750734759922943792393824427421186158236161317886392553095117188421298508307238259729144142251579403883011359083331651858234967221259621812507058113759495525022747274674369887131926670769299199084467161228738858457584622726573330753735572823951616964175198675012681745429323738294143824814377139861906716657572945807804820559511881687188075212971832636442155336787751274766940790117057509819575084563565217389544179875074523854455200133572033332379895074393905312918212255259833790909463630202185353848854825062897715616963860712382771725621313460549401770413581731931763370136332252819127547191443450920711848838366818174263342949611870091503049165339464763717766439120798347494627397822171502090670190302469762151278521956142070806461631373236517853976292092025500288962012970141379640038055734949269073535145961208674796547733692958773628635660143767964038430796864138563447801328261284589184898528048048844180821639423974014362903481665458114454366460032490618763039502356402044530748210241366895196644221339200757479128683805175150634662569391937740283512075666260829890491877287833852178522792045771846965855278790447562192663992008409302075673925363735628390829817577902153202106409617373283598494066652141198183810884515459772895164572131897797907491941013148368544639616904607030107596818933741217575988165127000761262789169510406315857637534787420070222051070891257612361658026806815858499852631465878086616800733264676830206391697203064894405628195406190685242003053463156621891327309069687353181641094514288036605995220248248886711554429104721929134248346438705368508648749099178812670565665387191049721820042371492740164460943459845392536706132210616533085662021188968234005752675486101476993688738209584552211571923479686888160853631615862880150395949418529489227074410828207169303387818084936204018255222271010985653444817207470756019245915599431072949578197878590578940052540122867517142511184356437184053563024181225473266093302710397968091064939272722683035410467632591355279683837705019855234621222858410557119921731717969804339317707750755627056047831779844447637560254637033369247114220815519973691371975163241302748712199863404548248524570118553342675264715978310731245663429805221455494156252724028915333354349341217862037007260315279870771872491234494477147909520734761385425485311552773301030342476835865496093722324007154518129732692081058424090557725645803681462234493189708138897143299831347617799679712453782310703739151473878692119187566700319321281896803322696594459286210607438827416919465162267632540665070881071030394178860564893769816734159025925194611823642945652669372203155504700213598846292758012527715422016629954863130324912311029627923723899766416803497141226527931907636326136814145516376656559839788489381733082668779901962886932296597379951931621187215455287394170243669885593888793316744533363119541518404088283815193421234122820030950313341050704760159987985472529190665222479319715440331794836837373220821885773341623856441380700541913530245943913502554531886454796252260251762928374330465102361057583514550739443339610216229675461415781127197001738611494279501411253280621254775810512972088465263158094806633687670147310733540717710876615935856814098212967730759197382973441445256688770855324570888958320993823432102718224114763732791357568615421252849657903335093152776925505845644010552192644505312073756287744998163646332835816140330175813967359427327690448920361880386754955751806890058532927201493923500525845146706982628548257883267398735220457228239290207144822219885587102896991935873074277815159757620764023951243860202032596596250212578349957710085626386118233813318509014686577064010676278617583772772895892746039403930337271873850536912957126715066896688493880885142943609962012966759079225082275313812849851526902931700263136328942095797577959327635531162066753488651317323872438748063513314512644889967589828812925480076425186586490241111127301357197181381602583178506932244007998656635371544088454866393181708395735780799059730839094881804060935959190907473960904410150516321749681412100765719177483767355751000733616922386537429079457803200042337452807566153042929014495780629634138383551783599764708851349004856973697965238695845994595592090709058956891451141412684505462117945026611750166928260250950770778211950432617383223562437601776799362796099368975191394965033358507155418436456852616674243688920371037495328425927131610537834980740739158633817967658425258036737206469351248652238481341663808061505704829059890696451936440018597120425723007316410009916987524260377362177763430621616744884930810929901009517974541564251204822086714586849255132444266777127863728211331536224301091824391243380214046242223349153559516890816288487989988273630445372432174280215755777967021666317047969728172483392841015642274507271779269399929740308072770395013581545142494049026536105825409373114653104943382484379718606937214444600826798002471229489405761853892203425608302697052876621377373594394224114707074072902725461307358541745691419446487624357682397065703184168467540733466346293673983620004041400714054277632480132742202685393698869787607009590048684650626771363070979821006557285101306601010780633743344773073478653881742681230743766066643312775356466578603715192922768440458273283243808212841218776132042460464900801054731426749260826922155637405486241717031027919996942645620955619816454547662045022411449404749349832206807191352767986747813458203859570413466177937228534940031631599544093684089572533438702986717829770373332806801764639502090023941931499115009105276821119510999063166150311585582835582607179410052528583611369961303442790173811787412061288182062023263849861515656451230047792967563618345768105043341769543067538041113928553792529241347339481050532025708728186307291158911335942014761872664291564036371927602306283840650425441742335464549987055318726887926424102147363698625463747159744354943443899730051742525110877357886390946812096673428152585919924857640488055071329814299359911463239919113959926752576359007446572810191805841807342227734721397723218231771716916400108826112549093361186780575722391018186168549108500885272274374212086524852372456248697662245384819298671129452945515497030585919307198497105414181636968976131126744027009648667545934567059936995464500558921628047976365686133316563907395703272034389175415267500915011198856872708848195531676931681272892143031376818016445477367518353497857924276463354162433601125960252109501612264110346083465648235597934274056868849224458745493776752120324703803035491157544831295275891939893680876327685438769557694881422844311998595700727521393176837831770339130423060958999137314684569010422095161967070506420256733873446115655276175992727151877660010238944760539789516945708802728736225121076224091810066700883474737605156285533943565843756271241244457651663064085939507947550920463932245202535463634444791755661725962187199279186575490857852950012840229035061514937310107009446151011613712423761426722541732055959202782129325725947146417224977321316381845326555279604270541871496236585252458648933254145062642337885651464670604298564781968461593663288954299780722542264790400616019751975007460545150060291806638271497016110987951336633771378434416194053121445291855180136575558667615019373029691932076120009255065081583275508499340768797252369987023567931026804136745718956641431852679054717169962990363015545645090044802789055701968328313630718997699153166679208958768572290600915472919636381673596673959975710326015571920237348580521128117458610065152598883843114511894880552129145775699146577530041384717124577965048175856395072895337539755822087777506072339445587895905719156735) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc.expected new file mode 100644 index 00000000..d55150f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/maximum-input/maximum-input.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc new file mode 100644 index 00000000..902471ce --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc @@ -0,0 +1,4 @@ +-- Negative inputs cause an error. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 0) (con integer -5)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/negative-input/negative-input.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc new file mode 100644 index 00000000..3e442a90 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc @@ -0,0 +1,4 @@ +-- Zero should encode to the empty bytestring. +(program 1.0.0 + [(builtin integerToByteString) (con bool False) (con integer 0) (con integer 0)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/integerToByteString/little-endian/unbounded/zero/zero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc new file mode 100644 index 00000000..4f4e2318 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc @@ -0,0 +1,17 @@ +-- Test vector (0-bit input) from ShortMsgKAT_256.txt in +-- https://keccak.team/obsolete/KeccakKAT-3.zip. The Keccak function we're +-- testing here is the version used by Ethereum, which was the Keccak submission +-- in round 3 of the SHA-3 competition. The final SHA-3 hash function is a +-- modified version of that. +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin keccak_256) + (con bytestring #) + ] + ] + (con bytestring #C5D2460186F7233C927E7DB2DCC703C0E500B653CA82273B7BFAD8045D85A470) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-empty/keccak_256-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc new file mode 100644 index 00000000..1f033a35 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc @@ -0,0 +1,17 @@ +-- Test vector (200-bit input) from ShortMsgKAT_256.txt in +-- https://keccak.team/obsolete/KeccakKAT-3.zip. The Keccak function we're +-- testing here is the version used by Ethereum, which was the Keccak submission +-- in round 3 of the SHA-3 competition. The final SHA-3 hash function is a +-- modified version of that. +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin keccak_256) + (con bytestring #AAFDC9243D3D4A096558A360CC27C8D862F0BE73DB5E88AA55) + ] + ] + (con bytestring #6FFFA070B865BE3EE766DC2DB49B6AA55C369F7DE3703ADA2612D754145C01E6) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/keccak_256/keccak_256-length-200/keccak_256-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc new file mode 100644 index 00000000..b44e937b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc @@ -0,0 +1,7 @@ +-- Measuring the length of an empty array +(program 1.1.0 + [ + (force (builtin lengthOfArray)) + (con (array bool) []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc.expected new file mode 100644 index 00000000..dc82b45b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-01/lengthOfArray-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc new file mode 100644 index 00000000..16f28837 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc @@ -0,0 +1,7 @@ +-- Measuring the length of a non-empty array +(program 1.1.0 + [ + (force (builtin lengthOfArray)) + (con (array bool) [True, False, True]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc.expected new file mode 100644 index 00000000..0b14f2e0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfArray/lengthOfArray-02/lengthOfArray-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 3)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc new file mode 100644 index 00000000..ed9ef889 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin lengthOfByteString) (con bytestring #00ffaa) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc.expected new file mode 100644 index 00000000..81805779 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lengthOfByteString/lengthOfByteString.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 3)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc new file mode 100644 index 00000000..35f00df3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [(builtin lessThanByteString) (con bytestring #00ff)] (con bytestring #00ffaa) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-00/lessThanByteString-00.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc new file mode 100644 index 00000000..0b5a044e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin equalsByteString) (con bytestring #54686543616B654973414C6965) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-01/lessThanByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc new file mode 100644 index 00000000..3f7173b5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanByteString) (con bytestring #54686543616B654973414C6965) (con bytestring #54686543616B65497341506965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-02/lessThanByteString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc new file mode 100644 index 00000000..8aa6ebc8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanByteString) (con bytestring #54686543616B65497341506965) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-03/lessThanByteString-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc new file mode 100644 index 00000000..3b70df6b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanByteString) (con bytestring #54686543616B65497341506965) (con bytestring #54686543616B654973414C69)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-04/lessThanByteString-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc new file mode 100644 index 00000000..320c18ec --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanByteString) (con bytestring #54686543616B654973414C69) (con bytestring #54686543616B65497341506965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanByteString/lessThanByteString-05/lessThanByteString-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc new file mode 100644 index 00000000..764b2576 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [(builtin lessThanEqualsByteString) (con bytestring #00ff)] (con bytestring #00) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-00/lessThanEqualsByteString-00.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc new file mode 100644 index 00000000..8bbb8ce1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsByteString) (con bytestring #54686543616B654973414C6964) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-01/lessThanEqualsByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc new file mode 100644 index 00000000..d79b6dc3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsByteString) (con bytestring #54686543616B654973414C6966) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-02/lessThanEqualsByteString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc new file mode 100644 index 00000000..a8106432 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsByteString) (con bytestring #54686543616B654973414C6965) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsByteString/lessThanEqualsByteString-03/lessThanEqualsByteString-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc new file mode 100644 index 00000000..80100652 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin lessThanEqualsInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-01/lessThanEqualsInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc new file mode 100644 index 00000000..38df5f47 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsInteger) (con integer 8) (con integer 4)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-02/lessThanEqualsInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc new file mode 100644 index 00000000..e78fc205 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsInteger) (con integer 4) (con integer 8)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-03/lessThanEqualsInteger-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc new file mode 100644 index 00000000..0e32e721 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsInteger) (con integer 4) (con integer 4)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-04/lessThanEqualsInteger-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc new file mode 100644 index 00000000..7e279e81 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanEqualsInteger) (con integer 3477349701412809834789938452452684373578934257) (con integer 3477349701412809834789938452452684373578934257)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanEqualsInteger/lessThanEqualsInteger-05/lessThanEqualsInteger-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc new file mode 100644 index 00000000..da9a4a8c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin lessThanInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-01/lessThanInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc new file mode 100644 index 00000000..56aee385 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanInteger) (con integer 8) (con integer 4)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-02/lessThanInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc new file mode 100644 index 00000000..9811d79f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanInteger) (con integer 4) (con integer 8)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-03/lessThanInteger-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc new file mode 100644 index 00000000..241cd924 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanInteger) (con integer 4) (con integer 4)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-04/lessThanInteger-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc new file mode 100644 index 00000000..37bf59ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin lessThanInteger) (con integer 3477349701412809834789938452452684373578934257) (con integer 3477349701412809834789938452452684373578934257)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lessThanInteger/lessThanInteger-05/lessThanInteger-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc new file mode 100644 index 00000000..ca81eb48 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin listData) (con (list data) [I 0, B #1234, Map [(I 9, List [B #abcd]), (B #4321, I 1234)]])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc.expected new file mode 100644 index 00000000..1958d3eb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listData/listData.uplc.expected @@ -0,0 +1,6 @@ +(program + 1.0.0 + (con + data (List [I 0, B #1234, Map [(I 9, List [B #abcd]), (B #4321, I 1234)]]) + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc new file mode 100644 index 00000000..42d1ba42 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 + (con (list (list integer)) [ [0], [0, 1, 2], [4, 5, 2] ]) +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc.expected new file mode 100644 index 00000000..3e69e9ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfList/listOfList.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (list integer)) [[0], [0,1,2], [4,5,2]])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc new file mode 100644 index 00000000..ee9e1cc7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (con (list (pair integer bool)) [(1, True), (500000, False), (0, True)]) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc.expected new file mode 100644 index 00000000..a464a0d6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listOfPair/listOfPair.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con (list (pair integer bool)) [(1, True), (500000, False), (0, True)]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc new file mode 100644 index 00000000..3373aff5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc @@ -0,0 +1,2 @@ +-- Convert an empty list to an array +(program 1.1.0 [ (force (builtin listToArray)) (con (list integer) []) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc.expected new file mode 100644 index 00000000..cfbbccf0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-01/listToArray-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con (array integer) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc new file mode 100644 index 00000000..bb69fc16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc @@ -0,0 +1,6 @@ +-- convert a non-empty list to an array +(program 1.1.0 + [ (force (builtin listToArray)) + (con (list integer) [11,22,33,44,55,66,77,88,99]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc.expected new file mode 100644 index 00000000..c55c8fcd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/listToArray/listToArray-02/listToArray-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con (array integer) [11,22,33,44,55,66,77,88,99])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc new file mode 100644 index 00000000..a6d8a668 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [ (builtin lookupCoin) + (con bytestring #aa) + (con bytestring #bb) + (con value [(#aa, [(#aa, 100)]), (#bb, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/absent/absent.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc new file mode 100644 index 00000000..e29d789c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [ (builtin lookupCoin) + (con bytestring #aa) + (con bytestring #aa) + (con value [(#aa, [(#aa, 100)]), (#bb, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc.expected new file mode 100644 index 00000000..e8ae2b63 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/lookupCoin/present/present.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 100)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc new file mode 100644 index 00000000..e3adb428 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin mapData) + (con (list (pair data data)) [(I 99, B #1234), (List [List [B #ef01, I -85]], Map [])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc.expected new file mode 100644 index 00000000..0f793227 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mapData/mapData.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (con data (Map [(I 99, B #1234), (List [List [B #ef01, I -85]], Map [])])) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc new file mode 100644 index 00000000..7d470cd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin divideInteger) (con integer 1) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/divideInteger/divideInteger.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc new file mode 100644 index 00000000..a198665e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[(force (builtin mkCons)) (con integer 0)] (con (list integer) [ ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc.expected new file mode 100644 index 00000000..3653f053 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-01/mkCons-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [0])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc new file mode 100644 index 00000000..41ac6be3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[(force (builtin mkCons)) (con integer 0)] (con (list integer) [ 1, 2 ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc.expected new file mode 100644 index 00000000..ffe6d990 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-02/mkCons-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list integer) [0,1,2])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc new file mode 100644 index 00000000..ccedfda6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc @@ -0,0 +1,4 @@ +-- a type mismatch +-- plutus implementation detail: note that this conceptually should be a machine type mismatch error (unlifting error), +-- but is currently a user evaluation failure, see: https://github.com/IntersectMBO/plutus/pull/3035 +(program 1.0.0 [(force (builtin mkCons)) (con integer 3) [(builtin mkNilData) (con unit ())]]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkCons/mkCons-fail/mkCons-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc new file mode 100644 index 00000000..833fc1f3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin mkNilData) (con unit ())]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc.expected new file mode 100644 index 00000000..56d93d06 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilData/mkNilData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list data) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc new file mode 100644 index 00000000..01809621 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin mkNilPairData) (con unit ())]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc.expected new file mode 100644 index 00000000..8efaedf9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkNilPairData/mkNilPairData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (pair data data)) [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc new file mode 100644 index 00000000..476f240a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ + [(builtin mkPairData) + (con data (List [I 0, B #ff])) + ] + (con data (Constr 1234 [I 3])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc.expected new file mode 100644 index 00000000..e90deb10 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/mkPairData/mkPairData.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (pair data data) (List [I 0, B #ff], Constr 1234 [I 3]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc new file mode 100644 index 00000000..02bf787d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin modInteger) (con integer 2) ] (con integer 3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-01/modInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc new file mode 100644 index 00000000..556d9bba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin modInteger) (con integer -503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc.expected new file mode 100644 index 00000000..50009a04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-neg/modInteger-neg-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc new file mode 100644 index 00000000..16693aa3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin modInteger) (con integer -503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc.expected new file mode 100644 index 00000000..ed7d62be --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-neg-pos/modInteger-neg-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1777777274)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc new file mode 100644 index 00000000..fa5b7ed7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin modInteger) (con integer 503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc.expected new file mode 100644 index 00000000..6679bca3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-neg/modInteger-pos-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1777777274)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc new file mode 100644 index 00000000..8a93ecd9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin modInteger) (con integer 503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc.expected new file mode 100644 index 00000000..2cb4ba16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-pos-pos/modInteger-pos-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc new file mode 100644 index 00000000..d5cdd5db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin modInteger) (con integer 1) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/modInteger/modInteger-zero/modInteger-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc new file mode 100644 index 00000000..b95eb85d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer 1) ] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-01/multiplyInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc new file mode 100644 index 00000000..7bfef64b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer 793479793478939166266268485555555) ] (con integer 0) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-02/multiplyInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc new file mode 100644 index 00000000..53b0e061 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer 793479793478939) ] (con integer 166266268485555555) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc.expected new file mode 100644 index 00000000..b6b6b0b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-03/multiplyInteger-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 131928924380432445633603606956145)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc new file mode 100644 index 00000000..c7be4f5e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer 793479793478939) ] (con integer -166266268485555555) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc.expected new file mode 100644 index 00000000..ce23b66e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-04/multiplyInteger-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -131928924380432445633603606956145)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc new file mode 100644 index 00000000..0f29a07e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer -793479793478939) ] (con integer 166266268485555555) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc.expected new file mode 100644 index 00000000..ce23b66e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-05/multiplyInteger-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -131928924380432445633603606956145)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc new file mode 100644 index 00000000..2a8153be --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin multiplyInteger) (con integer -793479793478939) ] (con integer -166266268485555555) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc.expected new file mode 100644 index 00000000..b6b6b0b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/multiplyInteger/multiplyInteger-06/multiplyInteger-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 131928924380432445633603606956145)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc new file mode 100644 index 00000000..93fc618f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin nullList)) (con (list integer) [ 1, 2, 3 ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-01/nullList-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc new file mode 100644 index 00000000..58ad6433 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin nullList)) (con (list integer) [ ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/nullList/nullList-02/nullList-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc new file mode 100644 index 00000000..5863168c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool False) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc new file mode 100644 index 00000000..39284d2d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc new file mode 100644 index 00000000..ee4e9f7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc new file mode 100644 index 00000000..acd76308 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool False) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc new file mode 100644 index 00000000..18eedd66 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool False) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc new file mode 100644 index 00000000..2d6865c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool True) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc new file mode 100644 index 00000000..f83daa73 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc new file mode 100644 index 00000000..c49b41bd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc new file mode 100644 index 00000000..134c7231 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool True) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc new file mode 100644 index 00000000..dede96f5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin orByteString) (con bool True) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc.expected new file mode 100644 index 00000000..b9430a48 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc new file mode 100644 index 00000000..b1782f72 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin orByteString) + (con bool False) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc.expected new file mode 100644 index 00000000..33ec69cb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-11/case-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #fbdef6de9da7d1bfbde8db3b3bbebf6ecffdc1dffc6bf3dd7f613e57df8fd7ffdd7fefb6e7be5ecfdff7f8 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc new file mode 100644 index 00000000..d95ffea0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin orByteString) + (con bool True) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc.expected new file mode 100644 index 00000000..c3a898a6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-12/case-12.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #fbdef6de9da7d1bfbde8db3b3bbebf6ecffdc1dffc6bf3dd7f613e57df8fd7ffdd7fefb6e7be5ecfdff7f81b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc new file mode 100644 index 00000000..43b4ee80 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin orByteString) + (con bool False) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc.expected new file mode 100644 index 00000000..33ec69cb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-13/case-13.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #fbdef6de9da7d1bfbde8db3b3bbebf6ecffdc1dffc6bf3dd7f613e57df8fd7ffdd7fefb6e7be5ecfdff7f8 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc new file mode 100644 index 00000000..7ea83582 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin orByteString) + (con bool True) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc.expected new file mode 100644 index 00000000..c3a898a6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/orByteString/case-14/case-14.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #fbdef6de9da7d1bfbde8db3b3bbebf6ecffdc1dffc6bf3dd7f613e57df8fd7ffdd7fefb6e7be5ecfdff7f81b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc new file mode 100644 index 00000000..fb519589 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + (con + (pair (pair bool bytestring) (list integer)) + ((True, #012345), [0, 1, 2]) + ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc.expected new file mode 100644 index 00000000..66cfd073 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/pairOfPairAndList/pairOfPairAndList.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (con (pair (pair bool bytestring) (list integer)) ((True, #012345), [0,1,2])) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc new file mode 100644 index 00000000..f3f28335 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin quotientInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-01/quotientInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc new file mode 100644 index 00000000..4310cc84 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin quotientInteger) (con integer -503783783785265728700234277) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc.expected new file mode 100644 index 00000000..8b788167 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-neg/quotientInteger-neg-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 283378378503190012)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc new file mode 100644 index 00000000..fc14f186 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin quotientInteger) (con integer -503783783785265728700234277) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc.expected new file mode 100644 index 00000000..365002c9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-neg-pos/quotientInteger-neg-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -283378378503190012)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc new file mode 100644 index 00000000..5a9c16c2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin quotientInteger) (con integer 503783783785265728700234277) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc.expected new file mode 100644 index 00000000..365002c9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-neg/quotientInteger-pos-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -283378378503190012)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc new file mode 100644 index 00000000..0bd536ba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin quotientInteger) (con integer 503783783785265728700234277) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc.expected new file mode 100644 index 00000000..8b788167 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-pos-pos/quotientInteger-pos-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 283378378503190012)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc new file mode 100644 index 00000000..c9d09922 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin quotientInteger) (con integer 1) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/quotientInteger/quotientInteger-zero/quotientInteger-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc new file mode 100644 index 00000000..642688e7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #) ] (con integer 0) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc new file mode 100644 index 00000000..b66f93b3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #) ] (con integer 345) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc new file mode 100644 index 00000000..67fc3d0e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #) ] (con integer -1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc new file mode 100644 index 00000000..3f5d40ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #ff) ] (con integer -1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc new file mode 100644 index 00000000..acd1ac29 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 0) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc new file mode 100644 index 00000000..dc836abd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc new file mode 100644 index 00000000..0b79ff7d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc new file mode 100644 index 00000000..45701346 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc new file mode 100644 index 00000000..e19a15e4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 4) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc new file mode 100644 index 00000000..067aceea --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 5) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc new file mode 100644 index 00000000..5f2ab504 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 6) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-11/case-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc new file mode 100644 index 00000000..219cb1c6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 7) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-12/case-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc new file mode 100644 index 00000000..2b80322e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4) ] (con integer 8) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-13/case-13.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc new file mode 100644 index 00000000..59490879 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #fff4) ] (con integer 16) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-14/case-14.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc new file mode 100644 index 00000000..1abdabae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin readBit) (con bytestring #f4ff) ] (con integer 10) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-15/case-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc new file mode 100644 index 00000000..a19fe4e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 341) -- Third bit from left end: 1 + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-16/case-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc new file mode 100644 index 00000000..8ba18504 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 343) -- Leftmost bit: 0 + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-17/case-17.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc new file mode 100644 index 00000000..af45bec0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 344) -- Just past the end + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-18/case-18.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc new file mode 100644 index 00000000..8e378d3c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775807) -- maxBound :: Int64 + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-19/case-19.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc new file mode 100644 index 00000000..32d93038 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775808) -- (maxBound :: Int64) + 1 + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-20/case-20.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc new file mode 100644 index 00000000..fd522e9b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775808) -- (minBound :: Int64) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-21/case-21.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc new file mode 100644 index 00000000..6a14bf99 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin readBit) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775809) -- (minBound :: Int64) - 1 + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/readBit/case-22/case-22.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc new file mode 100644 index 00000000..d82d0d53 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin remainderInteger) (con integer 1) ] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-01/remainderInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc new file mode 100644 index 00000000..bca6865f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin remainderInteger) (con integer -503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc.expected new file mode 100644 index 00000000..50009a04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-neg/remainderInteger-neg-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc new file mode 100644 index 00000000..afd4b042 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin remainderInteger) (con integer -503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc.expected new file mode 100644 index 00000000..50009a04 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-neg-pos/remainderInteger-neg-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc new file mode 100644 index 00000000..01d4d0f5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin remainderInteger) (con integer 503) (con integer -1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc.expected new file mode 100644 index 00000000..2cb4ba16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-neg/remainderInteger-pos-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc new file mode 100644 index 00000000..082f0816 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin remainderInteger) (con integer 503) (con integer 1777777777)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc.expected new file mode 100644 index 00000000..2cb4ba16 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-pos-pos/remainderInteger-pos-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 503)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc new file mode 100644 index 00000000..5103a827 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(builtin remainderInteger) (con integer 1) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/remainderInteger/remainderInteger-zero/remainderInteger-zero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc new file mode 100644 index 00000000..b4d33dd1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer -1) ] (con integer 0) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc new file mode 100644 index 00000000..002b6884 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer -1) ] (con integer 3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc new file mode 100644 index 00000000..34ef0fce --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 1) ] (con integer -1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc new file mode 100644 index 00000000..ffbf5956 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 1) ] (con integer 256) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc new file mode 100644 index 00000000..ced967f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 4) ] (con integer -1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc new file mode 100644 index 00000000..b2c190bb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 4) ] (con integer 256) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc new file mode 100644 index 00000000..4e2d5106 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 0) ] (con integer 255) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc new file mode 100644 index 00000000..817123e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin replicateByte) (con integer 4) ] (con integer 255) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc.expected new file mode 100644 index 00000000..b6b8a188 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ffffffff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc new file mode 100644 index 00000000..bc68fbf8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc @@ -0,0 +1,2 @@ +-- Maximum allowed length +(program 1.0.0 [ [ (builtin replicateByte) (con integer 8192) ] (con integer 141) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc.expected new file mode 100644 index 00000000..26143157 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-09/case-09.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc new file mode 100644 index 00000000..6eddbe0e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc @@ -0,0 +1,2 @@ +-- One greater than the maximum allowed length +(program 1.0.0 [ [ (builtin replicateByte) (con integer 8193) ] (con integer 141) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/replicateByte/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc new file mode 100644 index 00000000..56d9fa2d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) for Ripemd_160. +-- Output obtained using the online tool https://emn178.github.io/online-tools/ripemd_160.html +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin ripemd_160) + (con bytestring #) + ] + ] + (con bytestring #9c1185a5c5e9fc54612808977ee8f548b2258d31) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-empty/ripemd_160-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc new file mode 100644 index 00000000..c44ab03a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) for Ripemd_160. +-- Output obtained using the online tool https://emn178.github.io/online-tools/ripemd_160.html +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin ripemd_160) + (con bytestring #2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200) + ] + ] + (con bytestring #f18921115370b049e99dfdd49fc92b371dd7c7e9) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/ripemd_160/ripemd_160-length-200/ripemd_160-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc new file mode 100644 index 00000000..4beb8f49 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #) ] (con integer 3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc new file mode 100644 index 00000000..72f8b7ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #) ] (con integer -1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc new file mode 100644 index 00000000..b8ab3637 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer 5) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..0207fcc0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #7f9d)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc new file mode 100644 index 00000000..b371aa6a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer -5) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..921ae6c3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #e75f)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc new file mode 100644 index 00000000..d3b80505 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer 16) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..803ad809 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ebfc)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc new file mode 100644 index 00000000..735a64ee --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer -16) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc.expected new file mode 100644 index 00000000..803ad809 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ebfc)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc new file mode 100644 index 00000000..0b7c0767 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer 21) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc.expected new file mode 100644 index 00000000..0207fcc0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #7f9d)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc new file mode 100644 index 00000000..c3c12e88 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin rotateByteString) (con bytestring #ebfc) ] (con integer -21) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc.expected new file mode 100644 index 00000000..921ae6c3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #e75f)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc new file mode 100644 index 00000000..13e5ad8a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc @@ -0,0 +1,10 @@ +-- Rotate by 0: the result should be the same as the input. +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc.expected new file mode 100644 index 00000000..d6af3df2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-09/case-09.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc new file mode 100644 index 00000000..c6783538 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc @@ -0,0 +1,10 @@ +-- Rotate by 1000 times the bit length: the result should be the same as the input. +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 344000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc.expected new file mode 100644 index 00000000..d6af3df2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-10/case-10.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc new file mode 100644 index 00000000..17a03441 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc @@ -0,0 +1,10 @@ +-- Rotate by -10000 times the bit length: the result should be the same as the input. +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -3440000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc.expected new file mode 100644 index 00000000..d6af3df2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-11/case-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc new file mode 100644 index 00000000..65d8d327 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 23) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc.expected new file mode 100644 index 00000000..25ac4288 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-12/case-12.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #6b42c2401dcee02d9d85ce5eb341f6e0673a15d84cabb09f220a8102b3ce9fb0d233d92e63ac51d819e178 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc new file mode 100644 index 00000000..12444edf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc @@ -0,0 +1,10 @@ +-- Rotate by (1000 times the bit length) + 23 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 344023) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc.expected new file mode 100644 index 00000000..25ac4288 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-13/case-13.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #6b42c2401dcee02d9d85ce5eb341f6e0673a15d84cabb09f220a8102b3ce9fb0d233d92e63ac51d819e178 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc new file mode 100644 index 00000000..b949d3e4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc @@ -0,0 +1,10 @@ +-- Rotate by (-10000 times the bit length) + 23 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -3439977) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc.expected new file mode 100644 index 00000000..25ac4288 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-14/case-14.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #6b42c2401dcee02d9d85ce5eb341f6e0673a15d84cabb09f220a8102b3ce9fb0d233d92e63ac51d819e178 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc new file mode 100644 index 00000000..f78d4a19 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc @@ -0,0 +1,10 @@ +-- Rotate by maxBound :: Int64 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775807) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc.expected new file mode 100644 index 00000000..6cb0ead2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-15/case-15.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #41f6e0673a15d84cabb09f220a8102b3ce9fb0d233d92e63ac51d819e1786b42c2401dcee02d9d85ce5eb3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc new file mode 100644 index 00000000..8d47b587 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc @@ -0,0 +1,10 @@ +-- Rotate by (maxBound :: Int64)+1 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775808) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-16/case-16.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc new file mode 100644 index 00000000..080907c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc @@ -0,0 +1,10 @@ +-- Rotate by minBound :: Int64 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775808) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc.expected new file mode 100644 index 00000000..b08e3aea --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-17/case-17.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #44150205679d3f61a467b25cc758a3b033c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc new file mode 100644 index 00000000..fd437236 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc @@ -0,0 +1,10 @@ +-- Rotate by (minBound :: Int64) - 1 +(program 1.0.0 + [ + [ + (builtin rotateByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775809) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/rotateByteString/case-18/case-18.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc new file mode 100644 index 00000000..8527443c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin scaleValue) + (con integer -2) + (con value [(#aa, [(#aa, 5), (#bb, -15), (#cc, 20)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc.expected new file mode 100644 index 00000000..72b90c1d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-neg/by-neg.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, -10), (#bb, 30), (#cc, -40)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc new file mode 100644 index 00000000..3715afc8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin scaleValue) + (con integer 2) + (con value [(#aa, [(#aa, 5), (#bb, -15), (#cc, 20)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc.expected new file mode 100644 index 00000000..d3e61b29 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-pos/by-pos.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 10), (#bb, -30), (#cc, 40)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc new file mode 100644 index 00000000..273a32e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin scaleValue) + (con integer 0) + (con value [(#aa, [(#aa, 5), (#bb, -15), (#cc, 20)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/by-zero/by-zero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc new file mode 100644 index 00000000..b3934546 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc @@ -0,0 +1,7 @@ +-- Computes (2^127) - 2, which stays under the maximum allowed value (2^127 - 1) +(program 1.0.0 + [ (builtin scaleValue) + (con integer 2) + (con value [(#aa, [(#aa, 85070591730234615865843651857942052863)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc.expected new file mode 100644 index 00000000..4c1e848d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-overflow/no-overflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#aa, [(#aa, 170141183460469231731687303715884105726)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc new file mode 100644 index 00000000..43e2d398 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc @@ -0,0 +1,7 @@ +-- This computes -(2^127), which is the minimum allowed value +(program 1.0.0 + [ (builtin scaleValue) + (con integer 2) + (con value [(#aa, [(#aa, -85070591730234615865843651857942052864)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc.expected new file mode 100644 index 00000000..5cf29681 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/no-underflow/no-underflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#aa, [(#aa, -170141183460469231731687303715884105728)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc new file mode 100644 index 00000000..5c55139f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc @@ -0,0 +1,7 @@ +-- Performs 2 * 2^126 = 2^127 which exceeds the maximum allowed value (2^127 - 1) +(program 1.0.0 + [ (builtin scaleValue) + (con integer 2) + (con value [(#aa, [(#aa, 85070591730234615865843651857942052864)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/overflow/overflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc new file mode 100644 index 00000000..ebae558f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc @@ -0,0 +1,7 @@ +-- Computes -(2^127) - 2, which exceeds the minimum allowed vallue of -(2^127) +(program 1.0.0 + [ (builtin scaleValue) + (con integer 2) + (con value [(#aa, [(#aa, -85070591730234615865843651857942052865)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/scaleValue/underflow/underflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc new file mode 100644 index 00000000..3e7d6c5a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) from SHA256ShortMessage.rsp in +-- https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/shs/shabytetestvectors.zip +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin sha2_256) + (con bytestring #) + ] + ] + (con bytestring #e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-empty/sha2_256-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc new file mode 100644 index 00000000..5ecbe883 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc @@ -0,0 +1,14 @@ +-- Test vector (200-bit input) from SHA256ShortMessage.rsp in +-- https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/shs/shabytetestvectors.zip +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin sha2_256) + (con bytestring #2e7ea84da4bc4d7cfb463e3f2c8647057afff3fbececa1d200) + ] + ] + (con bytestring #76e3acbc718836f2df8ad2d0d2d76f0cfa5fea0986be918f10bcee730df441b9) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha2_256/sha2_256-length-200/sha2_256-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc new file mode 100644 index 00000000..d47b4155 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc @@ -0,0 +1,14 @@ +-- Test vector (0-bit input) from SHA3_256ShortMessage.rsp in +-- https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/sha3/sha-3bytetestvectors.zip +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin sha3_256) + (con bytestring #) + ] + ] + (con bytestring #a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-empty/sha3_256-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc new file mode 100644 index 00000000..b75a17c7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc @@ -0,0 +1,14 @@ +-- Test vector (200-bit input) from SHA3_256ShortMessage.rsp in +-- https://csrc.nist.gov/CSRC/media/Projects/Cryptographic-Algorithm-Validation-Program/documents/sha3/sha-3bytetestvectors.zip +(program 1.0.0 + [ + [ + (builtin equalsByteString) + [ + (builtin sha3_256) + (con bytestring #9b3fdf8d448680840d6284f2997d3af55ffd85f6f4b33d7f8d) + ] + ] + (con bytestring #25005d10e84ff97c74a589013be42fb37f68db64bdfc7626efc0dd628077493a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sha3_256/sha3_256-length-200/sha3_256-length-200.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc new file mode 100644 index 00000000..2e306923 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #) ] (con integer 3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc new file mode 100644 index 00000000..9cf2ed93 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #) ] (con integer -3) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc new file mode 100644 index 00000000..06579fef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #ebfc) ] (con integer 5) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..a5c9c9a5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #7f80)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc new file mode 100644 index 00000000..03d52f81 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #ebfc) ] (con integer -5) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..92745a34 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #075f)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc new file mode 100644 index 00000000..562822ae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #ebfc) ] (con integer 16) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..2ebf084b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #0000)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc new file mode 100644 index 00000000..f26a14f4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin shiftByteString) (con bytestring #ebfc) ] (con integer -16) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc.expected new file mode 100644 index 00000000..2ebf084b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #0000)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc new file mode 100644 index 00000000..2b90fe21 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc @@ -0,0 +1,10 @@ +-- Shift by 0: the result should be the same as the input. +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc.expected new file mode 100644 index 00000000..d6af3df2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-07/case-07.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc new file mode 100644 index 00000000..31677486 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 23) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc.expected new file mode 100644 index 00000000..d862586e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-08/case-08.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #6b42c2401dcee02d9d85ce5eb341f6e0673a15d84cabb09f220a8102b3ce9fb0d233d92e63ac51d8000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc new file mode 100644 index 00000000..63418732 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -23) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc.expected new file mode 100644 index 00000000..51bbec09 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-09/case-09.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #0000006785e1ad0b0900773b80b67617397acd07db819ce8576132aec27c882a040acf3a7ec348cf64b98e + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc new file mode 100644 index 00000000..48dab8a6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 1000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-10/case-10.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc new file mode 100644 index 00000000..7fe030f6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc @@ -0,0 +1,9 @@ +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -1000000) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-11/case-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc new file mode 100644 index 00000000..897d1d05 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc @@ -0,0 +1,10 @@ +-- Shift by maxBound :: Int64 +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775807) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-12/case-12.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc new file mode 100644 index 00000000..ffda693e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc @@ -0,0 +1,10 @@ +-- Shift by (maxBound :: Int64) + 1 +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer 9223372036854775808) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-13/case-13.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc new file mode 100644 index 00000000..82122de1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc @@ -0,0 +1,10 @@ +-- Shift by minBound :: Int64 +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775808) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-14/case-14.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc new file mode 100644 index 00000000..c34231d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc @@ -0,0 +1,10 @@ +-- Shift by (minBound :: Int64) - 1 +(program 1.0.0 + [ + [ + (builtin shiftByteString) + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con integer -9223372036854775809) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/shiftByteString/case-15/case-15.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc new file mode 100644 index 00000000..f283831b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin sliceByteString) (con integer 3) (con integer 5) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc.expected new file mode 100644 index 00000000..2523d94e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-01/sliceByteString-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #43616b6549)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc new file mode 100644 index 00000000..2dfcd48d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin sliceByteString) (con integer -3) (con integer 5) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc.expected new file mode 100644 index 00000000..31f7fd67 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-02/sliceByteString-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #5468654361)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc new file mode 100644 index 00000000..004585d4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin sliceByteString) (con integer -3) (con integer 1234) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc.expected new file mode 100644 index 00000000..fba0ee4a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-03/sliceByteString-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #54686543616b654973414c6965)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc new file mode 100644 index 00000000..eaf02192 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin sliceByteString) (con integer 5) (con integer 3) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc.expected new file mode 100644 index 00000000..07f93cab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-04/sliceByteString-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #6b6549)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc new file mode 100644 index 00000000..f72177c2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin sliceByteString) (con integer 123456789123456789) (con integer 123456789123456789) (con bytestring #54686543616B654973414C6965)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sliceByteString/sliceByteString-05/sliceByteString-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc new file mode 100644 index 00000000..81949029 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(force (force (builtin sndPair))) + (con (pair bool bytestring) + (True, #012345))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc.expected new file mode 100644 index 00000000..670c57a9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/sndPair/sndPair.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #012345)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc new file mode 100644 index 00000000..b4b1d8af --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin subtractInteger) (con integer 1)] (con integer 2) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger-non-iter/subtractInteger-non-iter.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc new file mode 100644 index 00000000..8b3f8c63 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin subtractInteger) (con integer 1)] (con integer 1) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-01/subtractInteger-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc new file mode 100644 index 00000000..3d598ee0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin subtractInteger) (con integer 123423)] (con integer -794378954789297841) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc.expected new file mode 100644 index 00000000..35f6c006 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-02/subtractInteger-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 794378954789421264)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc new file mode 100644 index 00000000..d3d561fd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin subtractInteger) (con integer 134782734132417234781342718231486243)] (con integer 23443231) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc.expected new file mode 100644 index 00000000..c41097cc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-03/subtractInteger-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 134782734132417234781342718208043012)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc new file mode 100644 index 00000000..45b0f5a0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ [ (builtin subtractInteger) (con integer 0)] (con integer -327893248793249782347891) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc.expected new file mode 100644 index 00000000..d026cd96 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/subtractInteger/subtractInteger-04/subtractInteger-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 327893248793249782347891)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc new file mode 100644 index 00000000..3cc22804 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(force (builtin tailList)) (con (list integer) [ ])]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-01/tailList-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc new file mode 100644 index 00000000..e12d05bd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc @@ -0,0 +1,2 @@ +-- tail is partial like haskell's and blows up when given an empty list +(program 1.0.0 [(force (builtin tailList)) [(builtin mkNilData) (con unit ())]]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/tailList/tailList-partial/tailList-partial.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc new file mode 100644 index 00000000..56b7f23c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc @@ -0,0 +1 @@ +(program 1.0.0 [[(force (builtin trace)) (con string "Ola")] (con integer 2)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc.expected new file mode 100644 index 00000000..00abe6f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/trace/trace.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc new file mode 100644 index 00000000..f71779d8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc @@ -0,0 +1,3 @@ +( + program 1.0.0 [(builtin unBData) (con data(B #AF00))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc.expected new file mode 100644 index 00000000..b96f4f32 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-01/unBData-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #af00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc new file mode 100644 index 00000000..8181a4db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unBData) (con data (I 0))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unBData/unBData-fail/unBData-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc new file mode 100644 index 00000000..5242ed14 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unConstrData) (con data (Constr 1278 [B #ff31, I -7972, List [List []]]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc.expected new file mode 100644 index 00000000..e1269449 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-01/unConstrData-01.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (con (pair integer (list data)) (1278, [B #ff31, I -7972, List [List []]])) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc new file mode 100644 index 00000000..ee65b81a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unConstrData) (con data (B #AF00))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unConstrData/unConstrData-fail/unConstrData-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc new file mode 100644 index 00000000..a68f9c3d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc @@ -0,0 +1,3 @@ +( + program 1.0.0 [(builtin unIData) (con data (I -123456789))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc.expected new file mode 100644 index 00000000..05efb47d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-01/unIData-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -123456789)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc new file mode 100644 index 00000000..29924c7e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc @@ -0,0 +1,3 @@ +( + program 1.0.0 [(builtin unIData) (con data (B #AF00))] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unIData/unIData-fail/unIData-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc new file mode 100644 index 00000000..5b77ee8c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unListData) (con data (List [I 0, I 1]))] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc.expected new file mode 100644 index 00000000..c6a44541 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-01/unListData-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list data) [I 0, I 1])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc new file mode 100644 index 00000000..1015d1cd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unListData) (con data (B #AF00))] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unListData/unListData-fail/unListData-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc new file mode 100644 index 00000000..acb79c90 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unMapData) (con data (Map [(I 0, I 1)]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc.expected new file mode 100644 index 00000000..cfb4bbc3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-01/unMapData-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con (list (pair data data)) [(I 0, I 1)])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc new file mode 100644 index 00000000..c661cc58 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unMapData) (con data (B #AF00))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unMapData/unMapData-fail/unMapData-fail.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc new file mode 100644 index 00000000..5d8fd407 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc @@ -0,0 +1,14 @@ +-- Currency symbol with 33 bytes (> maxKeyLen) +(program 1.0.0 + [ + (builtin unValueData) + (con data + (Map + [ ( B #000000000000000000000000000000000000000000000000000000000000000000 + , Map [(B #, I 1)] + ) + ] + ) + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/currency-key-too-long/currency-key-too-long.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc new file mode 100644 index 00000000..8c90d916 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc @@ -0,0 +1,14 @@ +(program 1.0.0 + [ (builtin unValueData) + (con data + ( Map + [ (B #aa, Map [(B #aa, I 123)]) + , (B #bb, Map [(B #bb, I 2)]) + , (B #aa, Map [(B #aa, I -80)]) + , (B #cc, Map [(B #cc, I 2)]) + , (B #aa, Map [(B #aa, I -43)]) + ] + ) + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-cancel/data-duplicate-currencies-cancel.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc new file mode 100644 index 00000000..9ee3bd58 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc @@ -0,0 +1,14 @@ +(program 1.0.0 + [ (builtin unValueData) + (con data + ( Map + [ (B #aa, Map [(B #aa, I 123)]) + , (B #bb, Map [(B #bb, I 2)]) + , (B #aa, Map [(B #aa, I 80)]) + , (B #cc, Map [(B #cc, I 2)]) + , (B #aa, Map [(B #aa, I 43)]) + ] + ) + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies-merge/data-duplicate-currencies-merge.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc new file mode 100644 index 00000000..7d6a76ab --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #bb, I 100)]), (B #aa, Map [(B #cc, I 50)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-currencies/data-duplicate-currencies.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc new file mode 100644 index 00000000..d2f38988 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #bb, I 100), (B #bb, I 50)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-duplicate-tokens/data-duplicate-tokens.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc new file mode 100644 index 00000000..a11fae6d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-empty-tokens/data-empty-tokens.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc new file mode 100644 index 00000000..7820211c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #bb, Map [(B #aa, I 10)]), (B #aa, Map [(B #cc, I 20)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-currencies/data-unordered-currencies.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc new file mode 100644 index 00000000..51ff7b42 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #cc, I 100), (B #bb, I 50)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-unordered-tokens/data-unordered-tokens.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc new file mode 100644 index 00000000..cea10be6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #bb, I 0), (B #cc, I 100)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-quantity/data-zero-quantity.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc new file mode 100644 index 00000000..c671ff98 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #bb, I 100), (B #bb, I -100)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/data-zero-sum/data-zero-sum.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc new file mode 100644 index 00000000..89f24ef3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Map []))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/empty/empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc new file mode 100644 index 00000000..9392c87b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc @@ -0,0 +1,13 @@ +(program 1.0.0 + [ + (builtin unValueData) + (con data + (Map + [ ( B #0000000000000000000000000000000000000000000000000000000000000000 + , Map [(B #0000000000000000000000000000000000000000000000000000000000000000, I 1)] + ) + ] + ) + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc.expected new file mode 100644 index 00000000..c9e0221e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/max-key-len/max-key-len.uplc.expected @@ -0,0 +1,9 @@ +(program + 1.0.0 + (con + value + [ ( #0000000000000000000000000000000000000000000000000000000000000000 + , [ ( #0000000000000000000000000000000000000000000000000000000000000000 + , 1 ) ] ) ] + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc new file mode 100644 index 00000000..429e06e6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Map [(B #aa, Map [(B #aa, I 1)]), (B #bb, Map [(B #bb, I 2)])]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc.expected new file mode 100644 index 00000000..9dea032d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-currency/multi-currency.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 1)]), (#bb, [(#bb, 2)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc new file mode 100644 index 00000000..8cc88757 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Map [(B #aa, Map [(B #aa, I 5), (B #bb, I 10)])]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc.expected new file mode 100644 index 00000000..3ccec0a3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/multi-token/multi-token.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 5), (#bb, 10)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc new file mode 100644 index 00000000..cd7c9238 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Map [(B #, Map [(B #, I -100)])]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc.expected new file mode 100644 index 00000000..11df7636 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/negative-quantity/negative-quantity.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, -100)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc new file mode 100644 index 00000000..57500f47 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc @@ -0,0 +1,7 @@ +-- Currency symbol key is I instead of B +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(I 1, Map [(B #, I 1)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-currency/non-bytestring-currency.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc new file mode 100644 index 00000000..990578eb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc @@ -0,0 +1,7 @@ +-- Token name key is I instead of B +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(B #, Map [(I 1, I 1)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-bytestring-token/non-bytestring-token.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc new file mode 100644 index 00000000..9c93d040 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc @@ -0,0 +1,7 @@ +-- Quantity is B instead of I +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(B #, Map [(B #, B #ff)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-integer-quantity/non-integer-quantity.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc new file mode 100644 index 00000000..d54d24ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (B #ff))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-bytes/non-map-bytes.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc new file mode 100644 index 00000000..4604665f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Constr 0 []))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-constr/non-map-constr.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc new file mode 100644 index 00000000..7febe898 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (I 42))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-integer/non-map-integer.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc new file mode 100644 index 00000000..054d5727 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (List []))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-list/non-map-list.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc new file mode 100644 index 00000000..432194d3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc @@ -0,0 +1,7 @@ +-- Inner value should be Map but is I +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(B #, I 1)])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/non-map-tokens/non-map-tokens.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc new file mode 100644 index 00000000..e897bec9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc @@ -0,0 +1,7 @@ +-- Quantity > 2^127-1 +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(B #, Map [(B #, I 170141183460469231731687303715884105728)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-overflow/quantity-overflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc new file mode 100644 index 00000000..1ec8abc8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc @@ -0,0 +1,7 @@ +-- Quantity < -2^127 +(program 1.0.0 + [ + (builtin unValueData) + (con data (Map [(B #, Map [(B #, I -170141183460469231731687303715884105729)])])) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/quantity-underflow/quantity-underflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc new file mode 100644 index 00000000..694420c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [(builtin valueData) + [(builtin unValueData) + (con data (Map [(B #aa, Map [(B #bb, I 100)])])) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc.expected new file mode 100644 index 00000000..a54bc5a1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/roundtrip-from-data/roundtrip-from-data.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Map [(B #aa, Map [(B #bb, I 100)])]))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc new file mode 100644 index 00000000..248c45f1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin unValueData) (con data (Map [(B #, Map [(B #, I 1)])]))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc.expected new file mode 100644 index 00000000..bbf3c399 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/single-entry/single-entry.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 1)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc new file mode 100644 index 00000000..235000f4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc @@ -0,0 +1,14 @@ +-- Token name with 33 bytes (> maxKeyLen) +(program 1.0.0 + [ + (builtin unValueData) + (con data + (Map + [ ( B # + , Map [(B #000000000000000000000000000000000000000000000000000000000000000000, I 1)] + ) + ] + ) + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unValueData/token-key-too-long/token-key-too-long.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc new file mode 100644 index 00000000..7e29686d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin unionValue) + (con value [(#, [(#, 100000)])]) + (con value [(#, [(#, -100000)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-01/cancel-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc new file mode 100644 index 00000000..8e29fb6c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin unionValue) + (con value [(#, [(#, -100000)])]) + (con value [(#, [(#, 100000)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc.expected new file mode 100644 index 00000000..f3491084 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/cancel-02/cancel-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc new file mode 100644 index 00000000..e348bd8c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin unionValue) + (con value [(#, [(#, 100000)])]) + (con value [(#, [(#, 100000)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc.expected new file mode 100644 index 00000000..98489a8c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/combine/combine.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#, [(#, 200000)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc new file mode 100644 index 00000000..cca5fa12 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc @@ -0,0 +1,7 @@ +-- This adds up to 2^127 - 1, the maximum allowed value for a single token +(program 1.0.0 + [ (builtin unionValue) + (con value [(#aa, [(#aa, 170141183460469231731687303715884105726)])]) + (con value [(#aa, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc.expected new file mode 100644 index 00000000..62ea5bde --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-overflow/no-overflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#aa, [(#aa, 170141183460469231731687303715884105727)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc new file mode 100644 index 00000000..3c9da7c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc @@ -0,0 +1,8 @@ +-- This adds up to -2^-127, which is the minimum allowed value for a single +-- token +(program 1.0.0 + [ (builtin unionValue) + (con value [(#aa, [(#aa, -170141183460469231731687303715884105727)])]) + (con value [(#aa, [(#aa, -1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc.expected new file mode 100644 index 00000000..5cf29681 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/no-underflow/no-underflow.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.0.0 (con value [(#aa, [(#aa, -170141183460469231731687303715884105728)])]) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc new file mode 100644 index 00000000..2d0111c6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc @@ -0,0 +1,8 @@ +-- This would add up to 2^127, which is over the allowed maximum value of a +-- token +(program 1.0.0 + [ (builtin unionValue) + (con value [(#aa, [(#aa, 170141183460469231731687303715884105727)])]) + (con value [(#aa, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/overflow/overflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc new file mode 100644 index 00000000..d9feeccb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc @@ -0,0 +1,8 @@ +-- This would add up to (-2^-127 - 1), which is less than the allowed minimum value of a +-- token +(program 1.0.0 + [ (builtin unionValue) + (con value [(#aa, [(#aa, -170141183460469231731687303715884105728)])]) + (con value [(#aa, [(#aa, -1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/underflow/underflow.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc new file mode 100644 index 00000000..0728dc49 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin unionValue) + (con value []) + (con value [(#aa, [(#aa, 100000)]), (#bb, [(#aa, 125)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc.expected new file mode 100644 index 00000000..9f44081c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitl/unitl.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 100000)]), (#bb, [(#aa, 125)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc new file mode 100644 index 00000000..47b855e0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin unionValue) + (con value [(#aa, [(#aa, 100000)]), (#bb, [(#aa, 125)])]) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc.expected new file mode 100644 index 00000000..9f44081c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/unionValue/unitr/unitr.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#aa, 100000)]), (#bb, [(#aa, 125)])])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc new file mode 100644 index 00000000..076a0465 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc @@ -0,0 +1,8 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 10), (#bb, 2800)]), (#ffff, [(#8888, 100)])]) + (con value [(#aa, [(#aa, 10)]), (#1234, [(#abcd, 20)])]) + ] +) + + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/ccy-missing/ccy-missing.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc new file mode 100644 index 00000000..f980edfc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 10), (#bb, 2800)]), (#ffff, [(#8888, 100)])]) + (con value [(#aa, [(#aa, 10)]), (#ffff, [(#8888, 101)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-insufficient/multi-insufficient.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc new file mode 100644 index 00000000..4cd2319d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 10), (#bb, 2800)]), (#ffff, [(#8888, 100)])]) + (con value [(#aa, [(#aa, 10)]), (#ffff, [(#8888, 20)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/multi-sufficient/multi-sufficient.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc new file mode 100644 index 00000000..7df3190a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, -100)]), (#bb, [(#aa, -1)])]) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-empty/neg-empty.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc new file mode 100644 index 00000000..f2e0bc99 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, -10)])]) + (con value [(#aa, [(#aa, -10)])]) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-eq/neg-neg-eq.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc new file mode 100644 index 00000000..166baca2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, -10)])]) + (con value [(#aa, [(#aa, -9)])]) + ] +) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-gt/neg-neg-gt.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc new file mode 100644 index 00000000..c838d6cd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, -10)])]) + (con value [(#aa, [(#aa, -11)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-neg-lt/neg-neg-lt.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc new file mode 100644 index 00000000..467f6ba1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, -10)])]) + (con value [(#aa, [(#aa, 100)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/neg-pos/neg-pos.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc new file mode 100644 index 00000000..91563cba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 100)]), (#bb, [(#aa, 1)])]) + (con value []) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-empty/pos-empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc new file mode 100644 index 00000000..2ea2f662 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 100)])]) + (con value [(#aa, [(#aa, -10)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/pos-neg/pos-neg.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc new file mode 100644 index 00000000..eabb508f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#aa, 100)]), (#bb, [(#aa, 1)])]) + (con value [(#aa, [(#aa, 100)]), (#bb, [(#aa, 1)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/reflexive/reflexive.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc new file mode 100644 index 00000000..a894796e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc @@ -0,0 +1,6 @@ +(program 1.0.0 + [ (builtin valueContains) + (con value [(#aa, [(#bb, 100), (#cc, 2800)])]) + (con value [(#aa, [(#dd, 5)])]) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueContains/token-missing/token-missing.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc new file mode 100644 index 00000000..4c6a66fb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin valueData) (con value [])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc.expected new file mode 100644 index 00000000..cfa8424f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/empty/empty.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Map []))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc new file mode 100644 index 00000000..543de54a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin valueData) (con value [(#aa, [(#aa, 1)]), (#bb, [(#bb, 2)])])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc.expected new file mode 100644 index 00000000..217c177a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-currency/multi-currency.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (con data (Map [(B #aa, Map [(B #aa, I 1)]), (B #bb, Map [(B #bb, I 2)])])) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc new file mode 100644 index 00000000..d5fa6ece --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin valueData) (con value [(#aa, [(#aa, 5), (#bb, 10)])])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc.expected new file mode 100644 index 00000000..3435e11b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/multi-token/multi-token.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Map [(B #aa, Map [(B #aa, I 5), (B #bb, I 10)])]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc new file mode 100644 index 00000000..ce4718b4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin valueData) (con value [(#, [(#, -100)])])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc.expected new file mode 100644 index 00000000..8b42cae1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/negative-quantity/negative-quantity.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Map [(B #, Map [(B #, I -100)])]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc new file mode 100644 index 00000000..ed2f0501 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc @@ -0,0 +1,7 @@ +(program 1.0.0 + [(builtin unValueData) + [(builtin valueData) + (con value [(#aa, [(#bb, 100)])]) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc.expected new file mode 100644 index 00000000..bff22a08 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/roundtrip-from-value/roundtrip-from-value.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con value [(#aa, [(#bb, 100)])])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc new file mode 100644 index 00000000..de7ef8e8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(builtin valueData) (con value [(#, [(#, 1)])])] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc.expected new file mode 100644 index 00000000..dbd31c7f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/valueData/single-entry/single-entry.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con data (Map [(B #, Map [(B #, I 1)])]))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc new file mode 100644 index 00000000..aa7fae1b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc @@ -0,0 +1,7 @@ +-- the header of public key should be 02 or 03 +-- 04 is for uncompressed, we don't have uncompressed +-- other bits would also break, e.g. 01,05... +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #04e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/invalid-key/invalid-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc new file mode 100644 index 00000000..c2c98003 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f0101)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-key/long-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc new file mode 100644 index 00000000..278b9590 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f0101)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-msg/long-msg.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc new file mode 100644 index 00000000..38ce4314 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c0909)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/long-sig/long-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc new file mode 100644 index 00000000..186e78cd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-key/short-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc new file mode 100644 index 00000000..7e811c63 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-msg/short-msg.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc new file mode 100644 index 00000000..f2166eff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEcdsaSecp256k1Signature) + (con bytestring #02e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/short-sig/short-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc new file mode 100644 index 00000000..2dd9731e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Low r, low s signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc new file mode 100644 index 00000000..d8314d6e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and message as test-vector-01, alternative signature (high r, low s) +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #ccfd8a4781b4d69121727222f062d2c77e97496e1c701d3a0abd840207e6dcd1016c0ee3d92f1eec1ca335ec3eb285612fb82ee2c1d1f80e706b2e907dc60cc4) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc new file mode 100644 index 00000000..c5b18884 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc @@ -0,0 +1,17 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and message as test-vector-01, alternative signature (low r, high s) +-- Expect False (we don't accept signatures with high s components) +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #603e6e7bf67152188204f76f6274d38c477bdbc3954cdaa44e4ef49691a517ded5eaad30c2e69e3e9b124bcc48fa0e4d0aa0dfdb4ca9d537ea1dcd46c94b8f56 + ) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc new file mode 100644 index 00000000..7683f197 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and message as test-vector-01, low-s version of signature in test-vector-03 +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #603e6e7bf67152188204f76f6274d38c477bdbc3954cdaa44e4ef49691a517de2a1552cf3d1961c164edb433b705f1b1b00dfd0b629ecb03d5b4914606eab1eb) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc new file mode 100644 index 00000000..9558a499 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and message as test-vector-01, sha3_256 instead of sha2_256 +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha3_256) (con bytestring #)] + ] + (con bytestring #5958fe71b4498446de57d0416ab8c41155fc16d46844fbc3fc9898bfca6badf9777d01c5b74b002678bfe904e941c096b5faf613a37b4d518e0ca750abcfa020) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc new file mode 100644 index 00000000..0bf5eee7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and message as test-vector-01, sha3_256 instead of sha2_256, alternative signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha3_256) (con bytestring #)] + ] + (con bytestring #d7086f9d50c7bbdd739c16da7d16bbabff5b58fc982013c9bac6df7a7200e3fe496c38ef025c3adf1cd060e0a74112580d9d2226213d7e70f0eee726c484e986) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc new file mode 100644 index 00000000..08b77f4b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair and signature as test-vector-01, different message +-- Expect False +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #48656c6c6f210a)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc new file mode 100644 index 00000000..f94402a9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair as test-vector-01, different message with correct signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #48656c6c6f210a)] + ] + (con bytestring #3499b841ac6eeb300b0dc9ed50e9c196d2b74f1745540f120bf603c48189b0ee6c48eacc04f2c3d3095fa17e11cc3b7642331963d52a9177d0d0685c4b3ff17f) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc new file mode 100644 index 00000000..136e4e01 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair as test-vector-01, different message with alternative correct signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #48656c6c6f210a)] + ] + (con bytestring #fc73d27f308bb0d770db88794e2694cfe5db464764aaa8bcbcafc7c3cadb9e57244f01f2a056cf5345396e8c238972d536e4c67baa7387925d7e028f2192f5d9) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc new file mode 100644 index 00000000..a074baa4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key 144c76f7eaa087f00a0381d0b7d6ec59eac07d4ac21b58695c1118b10127d821 +-- Same message and signature as test-vector-01, different signing key +-- Expect False +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #03173d3b9b964301a4919be323571e64301904209a32631ccc76b42b89d38c6274) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc new file mode 100644 index 00000000..5ce46f15 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key 144c76f7eaa087f00a0381d0b7d6ec59eac07d4ac21b58695c1118b10127d821 +-- Same message as test-vector-01, different keypair with correct signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #03173d3b9b964301a4919be323571e64301904209a32631ccc76b42b89d38c6274) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #a40e8132923ca042d159f5fba7d2828a79dc212259121a3bfe63445bf3f620fe1b33215f4ca9eb5d41eb8e8304ddc0666236f381f3a88f54cd67740847e91b41) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc new file mode 100644 index 00000000..4105b6c4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same keypair as test-vector-01, large message with correct signature +-- Expect True +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #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)] + ] + (con bytestring #db1f0c781e2d69660525c6f502d38c83c2c62c7004e26d8b860dc9a81cadb3b72f2e2fef4d34b9c869754834e6c785962b3fd0cdd222f47b1a1f2f3388f26c90) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc new file mode 100644 index 00000000..e9595ae9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Random message, same signature as test-vector-01 +-- Expect False +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + (con bytestring #377a7d7e7f49244ab617b429ec3b6b764326868236abcfed239427834782abdb) + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc new file mode 100644 index 00000000..e7548fc7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same as test-vector-01, one bit changed in signature +-- Expect False +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a2c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc new file mode 100644 index 00000000..4cf2f86c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same as test-vector-01, one bit changed in verification key +-- Expect False +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621ecd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc new file mode 100644 index 00000000..980d21b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc @@ -0,0 +1,16 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same as test-vector-01, but verification key adjusted to be off the curve. +-- Expect error +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb61) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c63a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc new file mode 100644 index 00000000..e0f8186a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc @@ -0,0 +1,17 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same as test-vector-01, but with the r component of the signature adjusted to +-- be out of range (equal to the group order): one less -> False, not error +-- Expect error +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd03641413a2f3e7b5f509294a4c2e22feb697a16b792fabfebe9d0f38403b1c929836b5a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc new file mode 100644 index 00000000..55d9c022 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc @@ -0,0 +1,17 @@ +-- Generated using OpenSSL 3.0.14.4 +-- Signing key a1adc24fc72eeb3ca032f68134a21c83dbebed4d7088a3794dbe65b4570604fd +-- Same as test-vector-01, but with the s component of the signature adjusted to +-- be out of range (equal to the group order): one less -> False, not error +-- Expect error +(program 1.0.0 + [ + [ + [ + (builtin verifyEcdsaSecp256k1Signature) + (con bytestring #032e433589dce61863199171f4d1e3fa946a5832621fcd29559940a0950f96fb6f) + ] + [(builtin sha2_256) (con bytestring #)] + ] + (con bytestring #4941155e2303988a1be97a021fbaf9fe6064d05ea694bc5e89328f297154e5c6fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEcdsaSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc new file mode 100644 index 00000000..e4001965 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f0101)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-key/long-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc new file mode 100644 index 00000000..228da803 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c0909)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/long-sig/long-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc new file mode 100644 index 00000000..0d647c9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-key/short-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc new file mode 100644 index 00000000..306f3611 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/short-sig/short-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc new file mode 100644 index 00000000..cfc4a1be --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a)] + (con bytestring #)] + (con bytestring #e5564300c360ac729086e2cc806e828a84877f1eb8e5d974d873e065224901555fb8821590a33bacc61e39701cf9b46bd25bf5f0595bbe24655141438e7a100b)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-01/test-vector-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc new file mode 100644 index 00000000..71342f70 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #3d4017c3e843895a92b70aa74d1b7ebc9c982ccf2ec4968cc0cd55f12af4660c)] + (con bytestring #72)] + (con bytestring #92a009a9f0d4cab8720e820b5f642540a2b27b5416503f8fb3762223ebdb69da085ac1e43e15996e458f3613d0f11d8c387b2eaeb4302aeeb00d291612bb0c00)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-02/test-vector-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc new file mode 100644 index 00000000..919df47e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc @@ -0,0 +1,5 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #fc51cd8e6218a1a38da47ed00230f0580816ed13ba3303ac5deb911548908025)] + (con bytestring #af82)] + (con bytestring #6291d657deec24024827e69c3abe01a30ce548a284743a445e3680d7db5ac3ac18ff9b538d16f290ae67f760984dc6594a7c15e9716ed28dc027beceea1ec40a)]) + diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-03/test-vector-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc new file mode 100644 index 00000000..11fe8a81 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e61a185bcef2613a6c7cb79763ce945d3b245d76114dd440bcf5f2dc1aa57057)] + (con bytestring #cbc77b)] + (con bytestring #d9868d52c2bebce5f3fa5a79891970f309cb6591e3e1702a70276fa97c24b3a8e58606c38c9758529da50ee31b8219cba45271c689afa60b0ea26c99db19b00c)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-04/test-vector-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc new file mode 100644 index 00000000..bf75511b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #6df9340c138cc188b5fe4464ebaa3f7fc206a2d55c3434707e74c9fc04e20ebb)] + (con bytestring #5f4c8989)] + (con bytestring #124f6fc6b0d100842769e71bd530664d888df8507df6c56dedfdb509aeb93416e26b918d38aa06305df3095697c18b2aa832eaa52edc0ae49fbae5a85e150c07)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-05/test-vector-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc new file mode 100644 index 00000000..537848b7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-06/test-vector-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc new file mode 100644 index 00000000..fbbae9f4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #fbcfbfa40505d7f2be444a33d185cc54e16d615260e1640b2b5087b83ee3643d)] + (con bytestring #89010d855972)] + (con bytestring #6ed629fc1d9ce9e1468755ff636d5a3f40a5d9c91afd93b79d241830f7e5fa29854b8f20cc6eecbb248dbd8d16d14e99752194e4904d09c74d639518839d2300)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-07/test-vector-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc new file mode 100644 index 00000000..a3db5d0c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #98a5e3a36e67aaba89888bf093de1ad963e774013b3902bfab356d8b90178a63)] + (con bytestring #b4a8f381e70e7a)] + (con bytestring #6e0af2fe55ae377a6b7a7278edfb419bd321e06d0df5e27037db8812e7e3529810fa5552f6c0020985ca17a0e02e036d7b222a24f99b77b75fdd16cb05568107)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-08/test-vector-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc new file mode 100644 index 00000000..ef426085 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #f81fb54a825fced95eb033afcd64314075abfb0abd20a970892503436f34b863)] + (con bytestring #4284abc51bb67235)] + (con bytestring #d6addec5afb0528ac17bb178d3e7f2887f9adbb1ad16e110545ef3bc57f9de2314a5c8388f723b8907be0f3ac90c6259bbe885ecc17645df3db7d488f805fa08)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-09/test-vector-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc new file mode 100644 index 00000000..663b3a7b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #c1a49c66e617f9ef5ec66bc4c6564ca33de2a5fb5e1464062e6d6c6219155efd)] + (con bytestring #672bf8965d04bc5146)] + (con bytestring #2c76a04af2391c147082e33faacdbe56642a1e134bd388620b852b901a6bc16ff6c9cc9404c41dea12ed281da067a1513866f9d964f8bdd24953856c50042901)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-10/test-vector-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc new file mode 100644 index 00000000..048fe861 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #31b2524b8348f7ab1dfafa675cc538e9a84e3fe5819e27c12ad8bbc1a36e4dff)] + (con bytestring #33d7a786aded8c1bf691)] + (con bytestring #28e4598c415ae9de01f03f9f3fab4e919e8bf537dd2b0cdf6e79b9e6559c9409d9151a4c40f083193937627c369488259e99da5a9f0a87497fa6696a5dd6ce08)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-11/test-vector-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc new file mode 100644 index 00000000..6b979af3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #44b57ee30cdb55829d0a5d4f046baef078f1e97a7f21b62d75f8e96ea139c35f)] + (con bytestring #3486f68848a65a0eb5507d)] + (con bytestring #77d389e599630d934076329583cd4105a649a9292abc44cd28c40000c8e2f5ac7660a81c85b72af8452d7d25c070861dae91601c7803d656531650dd4e5c4100)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-12/test-vector-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc new file mode 100644 index 00000000..2c5db289 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #6fe83693d011d111131c4f3fbaaa40a9d3d76b30012ff73bb0e39ec27ab18257)] + (con bytestring #5a8d9d0a22357e6655f9c785)] + (con bytestring #0f9ad9793033a2fa06614b277d37381e6d94f65ac2a5a94558d09ed6ce922258c1a567952e863ac94297aec3c0d0c8ddf71084e504860bb6ba27449b55adc40e)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-13/test-vector-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc new file mode 100644 index 00000000..e7f1a15e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #a2eb8c0501e30bae0cf842d2bde8dec7386f6b7fc3981b8c57c9792bb94cf2dd)] + (con bytestring #b87d3813e03f58cf19fd0b6395)] + (con bytestring #d8bb64aad8c9955a115a793addd24f7f2b077648714f49c4694ec995b330d09d640df310f447fd7b6cb5c14f9fe9f490bcf8cfadbfd2169c8ac20d3b8af49a0c)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-14/test-vector-14.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc new file mode 100644 index 00000000..7a2bdad6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #cf3af898467a5b7a52d33d53bc037e2642a8da996903fc252217e9c033e2f291)] + (con bytestring #55c7fa434f5ed8cdec2b7aeac173)] + (con bytestring #6ee3fe81e23c60eb2312b2006b3b25e6838e02106623f844c44edb8dafd66ab0671087fd195df5b8f58a1d6e52af42908053d55c7321010092748795ef94cf06)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-15/test-vector-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc new file mode 100644 index 00000000..3261547b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #fd2a565723163e29f53c9de3d5e8fbe36a7ab66e1439ec4eae9c0a604af291a5)] + (con bytestring #0a688e79be24f866286d4646b5d81c)] + (con bytestring #f68d04847e5b249737899c014d31c805c5007a62c0a10d50bb1538c5f35503951fbc1e08682f2cc0c92efe8f4985dec61dcbd54d4b94a22547d24451271c8b00)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-16/test-vector-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc new file mode 100644 index 00000000..8c6dab42 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #34e5a8508c4743746962c066e4badea2201b8ab484de5c4f94476ccd2143955b)] + (con bytestring #c942fa7ac6b23ab7ff612fdc8e68ef39)] + (con bytestring #2a3d27dc40d0a8127949a3b7f908b3688f63b7f14f651aacd715940bdbe27a0809aac142f47ab0e1e44fa490ba87ce5392f33a891539caf1ef4c367cae54500c)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-17/test-vector-17.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc new file mode 100644 index 00000000..f55db9d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #0445e456dacc7d5b0bbed23c8200cdb74bdcb03e4c7b73f0a2b9b46eac5d4372)] + (con bytestring #7368724a5b0efb57d28d97622dbde725af)] + (con bytestring #3653ccb21219202b8436fb41a32ba2618c4a133431e6e63463ceb3b6106c4d56e1d2ba165ba76eaad3dc39bffb130f1de3d8e6427db5b71938db4e272bc3e20b)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-18/test-vector-18.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc new file mode 100644 index 00000000..2f318915 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #74d29127f199d86a8676aec33b4ce3f225ccb191f52c191ccd1e8cca65213a6b)] + (con bytestring #bd8e05033f3a8bcdcbf4beceb70901c82e31)] + (con bytestring #fbe929d743a03c17910575492f3092ee2a2bf14a60a3fcacec74a58c7334510fc262db582791322d6c8c41f1700adb80027ecabc14270b703444ae3ee7623e0a)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-19/test-vector-19.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc new file mode 100644 index 00000000..514090bd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #5b96dca497875bf9664c5e75facf3f9bc54bae913d66ca15ee85f1491ca24d2c)] + (con bytestring #8171456f8b907189b1d779e26bc5afbb08c67a)] + (con bytestring #73bca64e9dd0db88138eedfafcea8f5436cfb74bfb0e7733cf349baa0c49775c56d5934e1d38e36f39b7c5beb0a836510c45126f8ec4b6810519905b0ca07c09)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-20/test-vector-20.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc new file mode 100644 index 00000000..2d3d7fe4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #1ca281938529896535a7714e3584085b86ef9fec723f42819fc8dd5d8c00817f)] + (con bytestring #8ba6a4c9a15a244a9c26bb2a59b1026f21348b49)] + (con bytestring #a1adc2bc6a2d980662677e7fdff6424de7dba50f5795ca90fdf3e96e256f3285cac71d3360482e993d0294ba4ec7440c61affdf35fe83e6e04263937db93f105)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-21/test-vector-21.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc new file mode 100644 index 00000000..4c410b2f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #7fae45dd0a05971026d410bc497af5be7d0827a82a145c203f625dfcb8b03ba8)] + (con bytestring #1d566a6232bbaab3e6d8804bb518a498ed0f904986)] + (con bytestring #bb61cf84de61862207c6a455258bc4db4e15eea0317ff88718b882a06b5cf6ec6fd20c5a269e5d5c805bafbcc579e2590af414c7c227273c102a10070cdfe80f)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-22/test-vector-22.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc new file mode 100644 index 00000000..634939fc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #48359b850d23f0715d94bb8bb75e7e14322eaf14f06f28a805403fbda002fc85)] + (con bytestring #1b0afb0ac4ba9ab7b7172cddc9eb42bba1a64bce47d4)] + (con bytestring #b6dcd09989dfbac54322a3ce87876e1d62134da998c79d24b50bd7a6a797d86a0e14dc9d7491d6c14a673c652cfbec9f962a38c945da3b2f0879d0b68a921300)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-23/test-vector-23.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc new file mode 100644 index 00000000..df6a1363 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #fdb30673402faf1c8033714f3517e47cc0f91fe70cf3836d6c23636e3fd2287c)] + (con bytestring #507c94c8820d2a5793cbf3442b3d71936f35fe3afef316)] + (con bytestring #7ef66e5e86f2360848e0014e94880ae2920ad8a3185a46b35d1e07dea8fa8ae4f6b843ba174d99fa7986654a0891c12a794455669375bf92af4cc2770b579e0c)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-24/test-vector-24.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc new file mode 100644 index 00000000..05b5d18b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #b1d39801892027d58a8c64335163195893bfc1b61dbeca3260497e1f30371107)] + (con bytestring #d3d615a8472d9962bb70c5b5466a3d983a4811046e2a0ef5)] + (con bytestring #836afa764d9c48aa4770a4388b654e97b3c16f082967febca27f2fc47ddfd9244b03cfc729698acf5109704346b60b230f255430089ddc56912399d1122de70a)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-25/test-vector-25.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc new file mode 100644 index 00000000..dc89cdff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #d0c846f97fe28585c0ee159015d64c56311c886eddcc185d296dbb165d2625d6)] + (con bytestring #6ada80b6fa84f7034920789e8536b82d5e4678059aed27f71c)] + (con bytestring #16e462a29a6dd498685a3718b3eed00cc1598601ee47820486032d6b9acc9bf89f57684e08d8c0f05589cda2882a05dc4c63f9d0431d6552710812433003bc08)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-26/test-vector-26.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc new file mode 100644 index 00000000..d1d6bdf6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #2bf32ba142ba4622d8f3e29ecd85eea07b9c47be9d64412c9b510b27dd218b23)] + (con bytestring #82cb53c4d5a013bae5070759ec06c3c6955ab7a4050958ec328c)] + (con bytestring #881f5b8c5a030df0f75b6634b070dd27bd1ee3c08738ae349338b3ee6469bbf9760b13578a237d5182535ede121283027a90b5f865d63a6537dca07b44049a0f)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-27/test-vector-27.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc new file mode 100644 index 00000000..7ba69a12 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #94d23d977c33e49e5e4992c68f25ec99a27c41ce6b91f2bfa0cd8292fe962835)] + (con bytestring #a9a8cbb0ad585124e522abbfb40533bdd6f49347b55b18e8558cb0)] + (con bytestring #3acd39bec8c3cd2b44299722b5850a0400c1443590fd4861d59aae7496acb3df73fc3fdf7969ae5f50ba47dddc435246e5fd376f6b891cd4c2caf5d614b6170c)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-28/test-vector-28.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc new file mode 100644 index 00000000..d9ba95b7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #9d084aa8b97a6b9bafa496dbc6f76f3306a116c9d917e681520a0f914369427e)] + (con bytestring #5cb6f9aa59b80eca14f6a68fb40cf07b794e75171fba96262c1c6adc)] + (con bytestring #f5875423781b66216cb5e8998de5d9ffc29d1d67107054ace3374503a9c3ef811577f269de81296744bd706f1ac478caf09b54cdf871b3f802bd57f9a6cb9101)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-29/test-vector-29.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc new file mode 100644 index 00000000..b12c982e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #16cee8a3f2631834c88b670897ff0b08ce90cc147b4593b3f1f403727f7e7ad5)] + (con bytestring #32fe27994124202153b5c70d3813fdee9c2aa6e7dc743d4d535f1840a5)] + (con bytestring #d834197c1a3080614e0a5fa0aaaa808824f21c38d692e6ffbd200f7dfb3c8f44402a7382180b98ad0afc8eec1a02acecf3cb7fde627b9f18111f260ab1db9a07)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-30/test-vector-30.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc new file mode 100644 index 00000000..a365d035 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifyEd25519Signature) + (con bytestring #23be323c562dfd71ce65f5bba56a74a3a6dfc36b573d2f94f635c7f9b4fd5a5b)] + (con bytestring #bb3172795710fe00054d3b5dfef8a11623582da68bf8e46d72d27cece2aa)] + (con bytestring #0f8fad1e6bde771b4f5420eac75c378bae6db5ac6650cd2bc210c1823b432b48e016b10595458ffab92f7a8989b293ceb8dfed6c243a2038fc06652aaaf16f02)]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifyEd25519Signature/test-vector-31/test-vector-31.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc new file mode 100644 index 00000000..4b099314 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifySchnorrSecp256k1Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f0101)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-key/long-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc new file mode 100644 index 00000000..769f2d5b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifySchnorrSecp256k1Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c0909)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/long-sig/long-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc new file mode 100644 index 00000000..e7b28ce3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifySchnorrSecp256k1Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c09)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-key/short-key.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc new file mode 100644 index 00000000..861d46ac --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [[[(builtin verifySchnorrSecp256k1Signature) + (con bytestring #e253af0766804b869bb1595be9765b534886bbaab8305bf50dbc7f899bfb5f01)] + (con bytestring #18b6bec097)] + (con bytestring #b2fc46ad47af464478c199e1f8be169f1be6327c7f9a0a6689371ca94caf04064a01b22aff1520abd58951341603faed768cf78ce97ae7b038abfe456aa17c)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/short-sig/short-sig.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc new file mode 100644 index 00000000..c97681d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc @@ -0,0 +1,13 @@ +-- Test vector 0 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9) + ] + (con bytestring #0000000000000000000000000000000000000000000000000000000000000000) + ] + (con bytestring #e907831f80848d1069a5371b402410364bdf1c5f8307b0084c55f1ce2dca821525f66a4a85ea8b71e482a74f382d2ce5ebeee8fdb2172f477df4900d310536c0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-00/test-vector-00.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc new file mode 100644 index 00000000..ef702465 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc @@ -0,0 +1,13 @@ +-- Test vector 1 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #6896bd60eeae296db48a229ff71dfe071bde413e6d43f917dc8dcf8c78de33418906d11ac976abccb20b091292bff4ea897efcb639ea871cfa95f6de339e4b0a) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-01/test-vector-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc new file mode 100644 index 00000000..93bf9e19 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc @@ -0,0 +1,13 @@ +-- Test vector 2 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dd308afec5777e13121fa72b9cc1b7cc0139715309b086c960e18fd969774eb8) + ] + (con bytestring #7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c) + ] + (con bytestring #5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-02/test-vector-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc new file mode 100644 index 00000000..1a49baca --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc @@ -0,0 +1,13 @@ +-- Test vector 3 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True (test fails if msg is reduced modulo p or n) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #25d1dff95105f5253c4022f628a996ad3a0d95fbf21d468a1b33f8c160d8f517) + ] + (con bytestring #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + ] + (con bytestring #7eb0509757e246f19449885651611cb965ecc1a187dd51b64fda1edc9637d5ec97582b9cb13db3933705b32ba982af5af25fd78881ebb32771fc5922efc66ea3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-03/test-vector-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc new file mode 100644 index 00000000..ca134be6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc @@ -0,0 +1,13 @@ +-- Test vector 4 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #d69c3509bb99e412e68b0fe8544e72837dfa30746d8be2aa65975f29d22dc7b9) + ] + (con bytestring #4df3c3f68fcc83b27e9d42c90431a72499f17875c81a599b566c9889b9696703) + ] + (con bytestring #00000000000000000000003b78ce563f89a0ed9414f5aa28ad0d96d6795f9c6376afb1548af603b3eb45c9f8207dee1060cb71c04e80f593060b07d28308d7f4) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-04/test-vector-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc new file mode 100644 index 00000000..5998243d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc @@ -0,0 +1,13 @@ +-- Test vector 5 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect failure (public key not on the curve) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #eefdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #6cff5c3ba86c69ea4b7376f31a9bcb4f74c1976089b2d9963da2e5543e17776969e89b4c5564d00349106b8497785dd7d1d713a8ae82b32fa79d5f7fc407d39b) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-05/test-vector-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc new file mode 100644 index 00000000..7f609cfb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc @@ -0,0 +1,13 @@ +-- Test vector 6 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (has_even_y(R) is false) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #fff97bd5755eeea420453a14355235d382f6472f8568a18b2f057a14602975563cc27944640ac607cd107ae10923d9ef7a73c643e166be5ebeafa34b1ac553e2) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-06/test-vector-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc new file mode 100644 index 00000000..52523a5a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc @@ -0,0 +1,13 @@ +-- Test vector 7 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (negated message) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #1fa62e331edbc21c394792d2ab1100a7b432b013df3f6ff4f99fcb33e0e1515f28890b3edb6e7189b630448b515ce4f8622a954cfe545735aaea5134fccdb2bd) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-07/test-vector-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc new file mode 100644 index 00000000..27fe594a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc @@ -0,0 +1,13 @@ +-- Test vector 8 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (negated s value) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #6cff5c3ba86c69ea4b7376f31a9bcb4f74c1976089b2d9963da2e5543e177769961764b3aa9b2ffcb6ef947b6887a226e8d7c93e00c5ed0c1834ff0d0c2e6da6) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-08/test-vector-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc new file mode 100644 index 00000000..fd0d0613 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc @@ -0,0 +1,14 @@ +-- Test vector 9 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False +-- (sG - eP is infinite. Test fails in single verification if has_even_y(inf) is defined as true and x(inf) as 0) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #0000000000000000000000000000000000000000000000000000000000000000123dda8328af9c23a94c1feecfd123ba4fb73476f0d594dcb65c6425bd186051) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-09/test-vector-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc new file mode 100644 index 00000000..76107a89 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc @@ -0,0 +1,14 @@ +-- Test vector 10 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False +-- (sG - eP is infinite. Test fails in single verification if has_even_y(inf) is defined as true and x(inf) as 1) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #00000000000000000000000000000000000000000000000000000000000000017615fbaf5ae28864013c099742deadb4dba87f11ac6754f93780d5a1837cf197) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-10/test-vector-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc new file mode 100644 index 00000000..d4799ffc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc @@ -0,0 +1,13 @@ +-- Test vector 11 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (sig[0:32] is not an X coordinate on the curve) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #4a298dacae57395a15d0795ddbfd1dcb564da82b0f269bc70a74f8220429ba1d69e89b4c5564d00349106b8497785dd7d1d713a8ae82b32fa79d5f7fc407d39b) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-11/test-vector-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc new file mode 100644 index 00000000..8d949e45 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc @@ -0,0 +1,13 @@ +-- Test vector 12 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (sig[0:32] is equal to field size) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f69e89b4c5564d00349106b8497785dd7d1d713a8ae82b32fa79d5f7fc407d39b) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-12/test-vector-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc new file mode 100644 index 00000000..33c32fe6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc @@ -0,0 +1,13 @@ +-- Test vector 13 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect False (sig[32:64] is equal to curve order) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #dff1d77f2a671c5f36183726db2341be58feae1da2deced843240f7b502ba659) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #6cff5c3ba86c69ea4b7376f31a9bcb4f74c1976089b2d9963da2e5543e177769fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-13/test-vector-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc new file mode 100644 index 00000000..c871a36d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc @@ -0,0 +1,13 @@ +-- Test vector 14 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect failure (public key is not a valid X coordinate because it exceeds the field size) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc30) + ] + (con bytestring #243f6a8885a308d313198a2e03707344a4093822299f31d0082efa98ec4e6c89) + ] + (con bytestring #6cff5c3ba86c69ea4b7376f31a9bcb4f74c1976089b2d9963da2e5543e17776969e89b4c5564d00349106b8497785dd7d1d713a8ae82b32fa79d5f7fc407d39b) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-14/test-vector-14.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc new file mode 100644 index 00000000..aec501ed --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc @@ -0,0 +1,13 @@ +-- Test vector 15 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True (message of size 0) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #778caa53b4393ac467774d09497a87224bf9fab6f6e68b23086497324d6fd117) + ] + (con bytestring #) + ] + (con bytestring #71535db165ecd9fbbc046e5ffaea61186bb6ad436732fccc25291a55895464cf6069ce26bf03466228f19a3a62db8a649f2d560fac652827d1af0574e427ab63) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-15/test-vector-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc new file mode 100644 index 00000000..300a03b7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc @@ -0,0 +1,13 @@ +-- Test vector 16 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True (message of size 1 (added 2022-12) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #778caa53b4393ac467774d09497a87224bf9fab6f6e68b23086497324d6fd117) + ] + (con bytestring #11) + ] + (con bytestring #08a20a0afef64124649232e0693c583ab1b9934ae63b4c3511f3ae1134c6a303ea3173bfea6683bd101fa5aa5dbc1996fe7cacfc5a577d33ec14564cec2bacbf) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-16/test-vector-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc new file mode 100644 index 00000000..e20832d5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc @@ -0,0 +1,13 @@ +-- Test vector 17 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True (message of size 17) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #778caa53b4393ac467774d09497a87224bf9fab6f6e68b23086497324d6fd117) + ] + (con bytestring #0102030405060708090a0b0c0d0e0f1011) + ] + (con bytestring #5130f39a4059b43bc7cac09a19ece52b5d8699d1a71e3c52da9afdb6b50ac370c4a482b77bf960f8681540e25b6771ece1e5a37fd80e5a51897c5566a97ea5a5) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-17/test-vector-17.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc new file mode 100644 index 00000000..dc5a193e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc @@ -0,0 +1,13 @@ +-- Test vector 18 from https://raw.githubusercontent.com/bitcoin/bips/master/bip-0340/test-vectors.csv +-- Expect True (message of size 100) +(program 1.0.0 + [ + [ + [(builtin verifySchnorrSecp256k1Signature) + (con bytestring #778caa53b4393ac467774d09497a87224bf9fab6f6e68b23086497324d6fd117) + ] + (con bytestring #99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999) + ] + (con bytestring #403b12b0d8555a344175ea7ec746566303321e5dbfa8be6f091635163eca79a8585ed3e3170807e7c03b720fc54c7b23897fcba0e9d0b4a06894cfd249f22367) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/verifySchnorrSecp256k1Signature/test-vector-18/test-vector-18.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc new file mode 100644 index 00000000..4100d67c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #) ] (con (list integer) [0]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc new file mode 100644 index 00000000..febc1f79 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #) ] (con (list integer) [15]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc new file mode 100644 index 00000000..6adc004f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #) ] (con (list integer) [0]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc new file mode 100644 index 00000000..94f6546d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #) ] (con (list integer) [0,1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc new file mode 100644 index 00000000..d88ac47f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [-1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc new file mode 100644 index 00000000..eb220658 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [0,-1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc new file mode 100644 index 00000000..d07bc187 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [-1,0]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc new file mode 100644 index 00000000..3c6b1975 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [8]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc new file mode 100644 index 00000000..1e3251e1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [1,8]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc new file mode 100644 index 00000000..644baaa6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [8,1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc new file mode 100644 index 00000000..3fa32c48 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [0]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc.expected new file mode 100644 index 00000000..02bf0c41 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-11/case-11.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #fe)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc new file mode 100644 index 00000000..7b126f76 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc.expected new file mode 100644 index 00000000..328b1696 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-12/case-12.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #fd)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc new file mode 100644 index 00000000..824f951a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [2]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc.expected new file mode 100644 index 00000000..4050f9b8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-13/case-13.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #fb)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc new file mode 100644 index 00000000..1302a4e5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [3]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc.expected new file mode 100644 index 00000000..4d6863a9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-14/case-14.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f7)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc new file mode 100644 index 00000000..b22cacf3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [4]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc.expected new file mode 100644 index 00000000..088121d5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-15/case-15.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ef)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc new file mode 100644 index 00000000..25c4c48d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [5]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc.expected new file mode 100644 index 00000000..f8780150 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-16/case-16.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #df)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc new file mode 100644 index 00000000..52daf484 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [6]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc.expected new file mode 100644 index 00000000..15d3285f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-17/case-17.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #bf)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc new file mode 100644 index 00000000..7d7cdd32 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [7]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc.expected new file mode 100644 index 00000000..35d0c5f7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-18/case-18.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #7f)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc new file mode 100644 index 00000000..e3af27c7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [-1]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-19/case-19.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc new file mode 100644 index 00000000..58c84e97 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [0]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc.expected new file mode 100644 index 00000000..9f3c7471 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-20/case-20.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #01)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc new file mode 100644 index 00000000..c9c29b69 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [1]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc.expected new file mode 100644 index 00000000..7e135432 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-21/case-21.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #02)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc new file mode 100644 index 00000000..4cad9087 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [2]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc.expected new file mode 100644 index 00000000..147c8009 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-22/case-22.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #04)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc new file mode 100644 index 00000000..ea704380 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [3]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc.expected new file mode 100644 index 00000000..6c5da937 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-23/case-23.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #08)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc new file mode 100644 index 00000000..c046a136 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [4]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc.expected new file mode 100644 index 00000000..e7689cea --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-24/case-24.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #10)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc new file mode 100644 index 00000000..8bc796ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [5]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc.expected new file mode 100644 index 00000000..0f56b3d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-25/case-25.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #20)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc new file mode 100644 index 00000000..3339704a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [6]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc.expected new file mode 100644 index 00000000..ca11ac0b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-26/case-26.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #40)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc new file mode 100644 index 00000000..cb90b5c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [7]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc.expected new file mode 100644 index 00000000..f8c7744e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-27/case-27.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #80)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc new file mode 100644 index 00000000..af78ce50 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [8]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-28/case-28.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc new file mode 100644 index 00000000..d5622a66 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #f4ff) ] (con (list integer) [10]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc.expected new file mode 100644 index 00000000..334e0217 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-29/case-29.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc new file mode 100644 index 00000000..a5b2de0c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #f4ff) ] (con (list integer) [1,10]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc.expected new file mode 100644 index 00000000..3782838d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-30/case-30.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0fd)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc new file mode 100644 index 00000000..856c7fca --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #f4ff) ] (con (list integer) [10,1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc.expected new file mode 100644 index 00000000..3782838d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-31/case-31.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0fd)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc new file mode 100644 index 00000000..7c0ff5ae --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #f4ff) ] (con (list integer) [10,1,10,1,1,1,1,10,10,10,1,1,1,1,1,1,10,1]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc.expected new file mode 100644 index 00000000..3782838d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-32/case-32.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0fd)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc new file mode 100644 index 00000000..59ba1250 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #f4ff) ] (con (list integer) [1,10,1,10,1,10,1,10,1,10,1,10,10,10,10,11,11,9]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc.expected new file mode 100644 index 00000000..3782838d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-33/case-33.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #f0fd)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc new file mode 100644 index 00000000..0c18dfea --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc @@ -0,0 +1,19 @@ +(program 1.0.0 + [ + [ + (builtin writeBits) + [ + [ + [ + (builtin writeBits) + (con bytestring #00ff) + ] + (con (list integer) [10]) + ] + (con bool True) + ] + (con (list integer) [10]) + ] + (con bool False) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc.expected new file mode 100644 index 00000000..3b05f166 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-34/case-34.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc new file mode 100644 index 00000000..9ab252bd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc @@ -0,0 +1,19 @@ +(program 1.0.0 + [ + [ + (builtin writeBits) + [ + [ + [ + (builtin writeBits) + (con bytestring #00ff) + ] + (con (list integer) [10]) + ] + (con bool False) + ] + (con (list integer) [10]) + ] + (con bool True) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc.expected new file mode 100644 index 00000000..6dac2188 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-35/case-35.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #04ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc new file mode 100644 index 00000000..7a35424b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #ff) ] (con (list integer) [0]) ] + (con bool True) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-36/case-36.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc new file mode 100644 index 00000000..31ae6f5c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin writeBits) (con bytestring #00) ] (con (list integer) [0]) ] + (con bool False) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc.expected new file mode 100644 index 00000000..4624f0c5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-37/case-37.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc new file mode 100644 index 00000000..af51ab96 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin writeBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + (con (list integer) [340, 342, 343]) + ] + (con bool True) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc.expected new file mode 100644 index 00000000..3c632778 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-38/case-38.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #d0000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc new file mode 100644 index 00000000..ef5c4d40 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc @@ -0,0 +1,20 @@ +-- Later updates to duplicate indices take precedence. +(program 1.0.0 + [ + [ + (builtin writeBits) + [ + [ + [ + (builtin writeBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + (con (list integer) [340, 342, 343, 340, 342, 343]) + ] + (con bool True) + ] + (con (list integer) [340, 342, 343]) + ] + (con bool False) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-39/case-39.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc new file mode 100644 index 00000000..5b001bb4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin writeBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000) + ] + (con (list integer) [340, 342, 343]) + ] + (con bool False) + ] +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc.expected new file mode 100644 index 00000000..1d4a1034 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-40/case-40.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc new file mode 100644 index 00000000..a430b022 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc @@ -0,0 +1,8 @@ +-- An empty list of updates doesn't change anything. +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000) + (con (list integer) []) + (con bool False) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc.expected new file mode 100644 index 00000000..a11cb37a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-41/case-41.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc new file mode 100644 index 00000000..38d2a1d0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc @@ -0,0 +1,8 @@ +-- An empty list of updates doesn't change anything. +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #00000000000000000000000000000000000000000000000000000000000000000000000000000000) + (con (list integer) []) + (con bool True) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc.expected new file mode 100644 index 00000000..a11cb37a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-42/case-42.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #00000000000000000000000000000000000000000000000000000000000000000000000000000000 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc new file mode 100644 index 00000000..30cfc6b2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc @@ -0,0 +1,8 @@ +-- An empty list of updates doesn't change anything. +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) + (con (list integer) []) + (con bool False) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc.expected new file mode 100644 index 00000000..db983ee7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-43/case-43.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc new file mode 100644 index 00000000..d94833ee --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc @@ -0,0 +1,8 @@ +-- An empty list of updates doesn't change anything. +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) + (con (list integer) []) + (con bool True) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc.expected new file mode 100644 index 00000000..db983ee7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-44/case-44.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc new file mode 100644 index 00000000..d794e1de --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc @@ -0,0 +1,8 @@ +-- We can apply an empty list of updates to the empty bytestring +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #) + (con (list integer) []) + (con bool False) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-45/case-45.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc new file mode 100644 index 00000000..c459ded2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc @@ -0,0 +1,8 @@ +-- We can apply an empty list of updates to the empty bytestring +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #) + (con (list integer) []) + (con bool True) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-46/case-46.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc new file mode 100644 index 00000000..61c08ce3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc @@ -0,0 +1,8 @@ +-- Attempting to write to a negative position in the empty bytestring causes an error +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #) + (con (list integer) [-1]) + (con bool False) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-47/case-47.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc new file mode 100644 index 00000000..28628c6b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc @@ -0,0 +1,8 @@ +-- Attempting to write to a negative position in the empty bytestring causes an error +(program 1.0.0 +[ (builtin writeBits) + (con bytestring #) + (con (list integer) [-1]) + (con bool True) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/writeBits/case-48/case-48.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc new file mode 100644 index 00000000..8409628a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool False) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc new file mode 100644 index 00000000..cd596c13 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc.expected new file mode 100644 index 00000000..5dbd4047 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc new file mode 100644 index 00000000..839eba09 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool False) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc new file mode 100644 index 00000000..f6caa143 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool False) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc new file mode 100644 index 00000000..0e098534 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool False) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc.expected new file mode 100644 index 00000000..47db26e2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #bb)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc new file mode 100644 index 00000000..81722452 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool True) ] (con bytestring #) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc new file mode 100644 index 00000000..32dbd68b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc new file mode 100644 index 00000000..77a09a66 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool True) ] (con bytestring #ff) ] + (con bytestring #00) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc new file mode 100644 index 00000000..031655f0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool True) ] (con bytestring #00) ] + (con bytestring #ff) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc.expected new file mode 100644 index 00000000..f596b7aa --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #ff)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc new file mode 100644 index 00000000..06f914ef --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc @@ -0,0 +1,4 @@ +(program 1.0.0 [ + [ [ (builtin xorByteString) (con bool True) ] (con bytestring #4f00) ] + (con bytestring #f4) +]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc.expected new file mode 100644 index 00000000..55d3996e --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bytestring #bb00)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc new file mode 100644 index 00000000..838e4023 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin xorByteString) + (con bool False) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc.expected new file mode 100644 index 00000000..ba8cd3b9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-11/case-11.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #e85e76ca1d2751a724e899113936136ccc99c1dda863c3d46b612813de8dd7ded440ceb2c3be420a8f75e8 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc new file mode 100644 index 00000000..1a0e7a69 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin xorByteString) + (con bool True) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc.expected new file mode 100644 index 00000000..6c344675 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-12/case-12.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #e85e76ca1d2751a724e899113936136ccc99c1dda863c3d46b612813de8dd7ded440ceb2c3be420a8f75e81b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc new file mode 100644 index 00000000..d34b9365 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin xorByteString) + (con bool False) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc.expected new file mode 100644 index 00000000..ba8cd3b9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-13/case-13.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #e85e76ca1d2751a724e899113936136ccc99c1dda863c3d46b612813de8dd7ded440ceb2c3be420a8f75e8 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc new file mode 100644 index 00000000..2619f794 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc @@ -0,0 +1,12 @@ +(program 1.0.0 + [ + [ + [ + (builtin xorByteString) + (con bool True) + ] + (con bytestring #db9c861c98a3d19cb928c22a32aaae0a4f740113dc48734d3c001657cb8fd2b9497faf16a40c1ecdd7d6581b55b625553af3) + ] + (con bytestring #33c2f0d68584803b9dc05b3b0b9cbd6683edc0ce742bb09957613e44150205679d3f61a467b25cc758a3b0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc.expected new file mode 100644 index 00000000..6c344675 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/builtin/semantics/xorByteString/case-14/case-14.uplc.expected @@ -0,0 +1,7 @@ +(program + 1.0.0 + (con + bytestring + #e85e76ca1d2751a724e899113936136ccc99c1dda863c3d46b612813de8dd7ded440ceb2c3be420a8f75e81b55b625553af3 + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc new file mode 100644 index 00000000..601c56c3 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc @@ -0,0 +1,94 @@ +(program + 1.0.0 + [ + [ + (force (force (delay (delay (lam f (lam x [ f x ])))))) + [ + (builtin addInteger) + [ + (lam + x0 + [ + [ + (builtin multiplyInteger) + [ [ (builtin multiplyInteger) x0 ] x0 ] + ] + [ + [ + (builtin subtractInteger) + [ + [ (builtin subtractInteger) (con integer 0) ] + (con integer 1) + ] + ] + [ + [ (builtin subtractInteger) (con integer 3) ] (con integer 0) + ] + ] + ] + ) + [ + (lam + x1 + [ + [ + (builtin subtractInteger) + [ + [ (builtin multiplyInteger) (con integer 0) ] + (con integer 2) + ] + ] + [ [ (builtin addInteger) (con integer 0) ] (con integer 1) ] + ] + ) + [ + (lam + x2 + [ + [ (builtin subtractInteger) (con integer 2) ] (con integer 2) + ] + ) + [ (builtin sha3_256) (con bytestring #76) ] + ] + ] + ] + ] + ] + [ + (lam + x0 + [ + [ + (builtin addInteger) + [ + [ + (builtin addInteger) + [ + [ (builtin multiplyInteger) (con integer 2) ] (con integer 1) + ] + ] + [ [ (builtin addInteger) (con integer 2) ] (con integer 3) ] + ] + ] + [ + [ + (builtin subtractInteger) + [ [ (builtin subtractInteger) (con integer 1) ] (con integer 2) ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 1) ] + ] + ] + ) + [ + [ (builtin lessThanInteger) (con integer 3) ] + [ + [ + (builtin multiplyInteger) + [ [ (builtin addInteger) (con integer 2) ] (con integer 1) ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 0) ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd1/ApplyAdd1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc new file mode 100644 index 00000000..691d4641 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc @@ -0,0 +1,106 @@ +(program + 1.0.0 + [ + [ + [ + (force (force (delay (delay (lam f (lam x [ f x ])))))) + (builtin addInteger) + ] + [ + (lam + x0 + [ + [ + (builtin multiplyInteger) + [ + [ + (builtin subtractInteger) + [ + [ (builtin subtractInteger) (con integer 3) ] + (con integer 2) + ] + ] + [ [ (builtin addInteger) (con integer 2) ] (con integer 0) ] + ] + ] + [ + [ + (builtin subtractInteger) + [ + [ (builtin multiplyInteger) (con integer 3) ] (con integer 0) + ] + ] + [ [ (builtin multiplyInteger) (con integer 1) ] (con integer 1) ] + ] + ] + ) + [ + [ + (builtin lessThanEqualsInteger) + [ + [ + (builtin subtractInteger) + [ + [ (builtin multiplyInteger) (con integer 3) ] (con integer 3) + ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 3) ] + ] + ] + [ + [ + (builtin addInteger) + [ [ (builtin addInteger) (con integer 2) ] (con integer 3) ] + ] + [ [ (builtin subtractInteger) (con integer 3) ] (con integer 3) ] + ] + ] + ] + ] + [ + (lam + x0 + [ + (lam + x2 + [ + [ + (builtin addInteger) + [ + [ (builtin subtractInteger) (con integer 0) ] (con integer 3) + ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 1) ] + ] + ) + [ + [ + (builtin subtractInteger) + [ [ (builtin addInteger) (con integer 1) ] (con integer 1) ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 0) ] + ] + ] + ) + [ + (lam + x1 + [ + [ + (builtin lessThanInteger) + [ [ (builtin multiplyInteger) (con integer 0) ] (con integer 3) ] + ] + [ [ (builtin addInteger) (con integer 0) ] (con integer 1) ] + ] + ) + [ + [ + (builtin equalsInteger) + [ [ (builtin multiplyInteger) (con integer 3) ] (con integer 2) ] + ] + [ [ (builtin subtractInteger) (con integer 2) ] (con integer 0) ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc.expected new file mode 100644 index 00000000..1cb56cff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ApplyAdd2/ApplyAdd2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc new file mode 100644 index 00000000..b03716cc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc @@ -0,0 +1,50 @@ +(program + 1.0.0 + [ + [ + (builtin remainderInteger) + [ + (lam + x0 + [ + [ + (builtin addInteger) + [ + (lam + x1 + [ [ (builtin addInteger) (con integer 3) ] (con integer 3) ] + ) + [ + [ (builtin lessThanInteger) (con integer 1) ] (con integer 0) + ] + ] + ] + [ + (lam + x2 + [ + [ (builtin subtractInteger) (con integer 1) ] (con integer 3) + ] + ) + [ + [ (builtin equalsByteString) (con bytestring #7063) ] + (con bytestring #716466) + ] + ] + ] + ) + [ + (builtin sha2_256) + [ + [ + (builtin appendByteString) + [ (builtin sha2_256) (con bytestring #67696d) ] + ] + [ (builtin sha2_256) (con bytestring #767174) ] + ] + ] + ] + ] + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZero/DivideByZero.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc new file mode 100644 index 00000000..b5f6dfbb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc @@ -0,0 +1,44 @@ +(program + 1.0.0 + [ + [ (force (force (delay (delay (lam x (lam y x)))))) (con integer 0) ] + [ + [ + (builtin divideInteger) + [ + (lam + x0 + [ + (lam x2 x2) + [ + [ + (builtin multiplyInteger) + [ + [ (builtin multiplyInteger) (con integer 2) ] + (con integer 0) + ] + ] + [ + [ (builtin subtractInteger) (con integer 1) ] (con integer 1) + ] + ] + ] + ) + [ + (lam x1 (con integer 1)) + [ + [ + (builtin subtractInteger) + [ + [ (builtin multiplyInteger) (con integer 2) ] (con integer 3) + ] + ] + [ [ (builtin multiplyInteger) (con integer 2) ] (con integer 2) ] + ] + ] + ] + ] + (con integer 0) + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/DivideByZeroDrop/DivideByZeroDrop.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc new file mode 100644 index 00000000..11eebed8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc @@ -0,0 +1,91 @@ +(program + 1.0.0 + [ + [ + [ + (force + (delay + (lam + b + (lam + x + (lam + y + [ + [ [ [ (force (builtin ifThenElse)) b ] x ] y ] (con unit ()) + ] + ) + ) + ) + ) + ) + [ + (lam + x0 + [ + [ + (builtin equalsByteString) + [ + (builtin sha2_256) [ (builtin sha3_256) (con bytestring #64) ] + ] + ] + x0 + ] + ) + [ + [ + (builtin appendByteString) + [ + (lam x1 [ (builtin sha3_256) (con bytestring #78) ]) + [ (builtin sha3_256) (con bytestring #726e) ] + ] + ] + (con bytestring #6973) + ] + ] + ] + [ + (force (force (delay (delay (lam x (lam y x)))))) + [ + (lam + x0 + [ + (lam x2 x0) + [ (builtin sha2_256) [ (builtin sha3_256) (con bytestring #) ] ] + ] + ) + [ + [ + (builtin subtractInteger) + [ + [ + (builtin addInteger) + [ + [ (builtin subtractInteger) (con integer 2) ] + (con integer 2) + ] + ] + [ + [ (builtin subtractInteger) (con integer 1) ] (con integer 3) + ] + ] + ] + [ + (lam + x1 + [ + [ (builtin subtractInteger) (con integer 3) ] (con integer 3) + ] + ) + [ + [ (builtin equalsByteString) (con bytestring #6c7a) ] + (con bytestring #6673) + ] + ] + ] + ] + ] + ] + [ (force (force (delay (delay (lam x (lam y x)))))) (con integer 0) ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/IfIntegers/IfIntegers.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc new file mode 100644 index 00000000..fc04c311 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc @@ -0,0 +1,51 @@ +(program + 1.0.0 + [ + [ + [ + (force + (delay + (lam + f + [ + (force + (force + (delay + (delay + (lam + f + [ + (force (delay (lam s [ s s ]))) + (lam + s + (lam + x + [ + [ f [ (force (delay (lam s [ s s ]))) s ] ] x + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec + (lam + z + (lam n [ [ (force n) z ] (lam n' [ [ rec [ f z ] ] n' ]) ]) + ) + ) + ] + ) + ) + ) + [ (builtin addInteger) (con integer 1) ] + ] + (con integer 0) + ] + [ (lam n (delay (lam z (lam f [ f n ])))) (delay (lam z (lam f z))) ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc.expected new file mode 100644 index 00000000..8e9a3b22 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/NatRoundTrip/NatRoundTrip.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc new file mode 100644 index 00000000..12b47561 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc @@ -0,0 +1,64 @@ +(program + 1.0.0 + [ + [ + [ + (force + (force + (delay + (delay + (lam + f + [ + (force + (force + (delay + (delay + (lam + f + [ + (force (delay (lam s [ s s ]))) + (lam + s + (lam + x + [ + [ + f [ (force (delay (lam s [ s s ]))) s ] + ] + x + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec + (lam + z + (lam + xs + [ + [ (force xs) z ] + (lam x (lam xs' [ [ rec [ [ f z ] x ] ] xs' ])) + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + (builtin addInteger) + ] + (con integer 0) + ] + (force (delay (delay (lam z (lam f z))))) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/ScottListSum/ScottListSum.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc new file mode 100644 index 00000000..677a7e10 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc @@ -0,0 +1 @@ +(program 1.0.0 (lam n (delay (lam z (lam f [ f [ [ (force n) z ] f ] ]))))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc.expected new file mode 100644 index 00000000..8f1e95d1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchSucc/churchSucc.uplc.expected @@ -0,0 +1,4 @@ +(program + 1.0.0 + (lam n-0 (delay (lam z-1 (lam f-2 [ f-2 [ [ (force n-0) z-1 ] f-2 ] ])))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc new file mode 100644 index 00000000..5d1d5d7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc @@ -0,0 +1 @@ +(program 1.0.0 (delay (lam z (lam f z)))) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc.expected new file mode 100644 index 00000000..b9b8e8a8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/churchZero/churchZero.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (delay (lam z-0 (lam f-1 z-0)))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc new file mode 100644 index 00000000..eb7ad3c1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc @@ -0,0 +1,176 @@ +(program + 1.0.0 + [ + [ + (force + [ + (force + (force + (force + (force + (delay + (delay + (delay + (delay + (lam + f_7 + [ + [ + (force + (delay + (lam + by_1 + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force + (delay + (lam s_1 [ s_1 s_1 ]) + ) + ) + (lam + s_3 + (lam + x_4 + [ + [ + f_2 + [ + (force + (delay + (lam + s_1 + [ s_1 s_1 ] + ) + ) + ) + s_3 + ] + ] + x_4 + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec_8 + (lam + h_11 + (delay + (lam + fr_14 + [ + (force + [ + by_1 + (delay + (lam + fq_16 + [ + (force + [ rec_8 h_11 ] + ) + [ + (force h_11) fq_16 + ] + ] + ) + ) + ] + ) + fr_14 + ] + ) + ) + ) + ) + ] + ) + ) + ) + (lam + k_9 + (delay + (lam + h_12 + [ + [ + h_12 + (lam + x_15 + [ + (force k_9) + (lam + f_0_13 + (lam f_1_14 [ f_0_13 x_15 ]) + ) + ] + ) + ] + (lam + x_18 + [ + (force k_9) + (lam + f_0_16 + (lam f_1_17 [ f_1_17 x_18 ]) + ) + ] + ) + ] + ) + ) + ) + ] + f_7 + ] + ) + ) + ) + ) + ) + ) + ) + ) + ) + (delay + (lam + choose_5 + (lam + even_0 + (lam + odd_1 + [ + [ + choose_5 + (lam n_2 [ [ (force n_2) (con bool True) ] odd_1 ]) + ] + (lam n_3 [ [ (force n_3) (con bool False) ] even_0 ]) + ] + ) + ) + ) + ) + ] + ) + (lam arg_0_0 (lam arg_1_1 arg_0_0)) + ] + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + (delay (lam z_1 (lam f_2 z_1))) + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc.expected new file mode 100644 index 00000000..3760fc7a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even2/even2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool True)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc new file mode 100644 index 00000000..a2a7d1d5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc @@ -0,0 +1,179 @@ +(program + 1.0.0 + [ + [ + (force + [ + (force + (force + (force + (force + (delay + (delay + (delay + (delay + (lam + f_7 + [ + [ + (force + (delay + (lam + by_1 + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force + (delay + (lam s_1 [ s_1 s_1 ]) + ) + ) + (lam + s_3 + (lam + x_4 + [ + [ + f_2 + [ + (force + (delay + (lam + s_1 + [ s_1 s_1 ] + ) + ) + ) + s_3 + ] + ] + x_4 + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec_8 + (lam + h_11 + (delay + (lam + fr_14 + [ + (force + [ + by_1 + (delay + (lam + fq_16 + [ + (force + [ rec_8 h_11 ] + ) + [ + (force h_11) fq_16 + ] + ] + ) + ) + ] + ) + fr_14 + ] + ) + ) + ) + ) + ] + ) + ) + ) + (lam + k_9 + (delay + (lam + h_12 + [ + [ + h_12 + (lam + x_15 + [ + (force k_9) + (lam + f_0_13 + (lam f_1_14 [ f_0_13 x_15 ]) + ) + ] + ) + ] + (lam + x_18 + [ + (force k_9) + (lam + f_0_16 + (lam f_1_17 [ f_1_17 x_18 ]) + ) + ] + ) + ] + ) + ) + ) + ] + f_7 + ] + ) + ) + ) + ) + ) + ) + ) + ) + ) + (delay + (lam + choose_5 + (lam + even_0 + (lam + odd_1 + [ + [ + choose_5 + (lam n_2 [ [ (force n_2) (con bool True) ] odd_1 ]) + ] + (lam n_3 [ [ (force n_3) (con bool False) ] even_0 ]) + ] + ) + ) + ) + ) + ] + ) + (lam arg_0_0 (lam arg_1_1 arg_0_0)) + ] + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + (delay (lam z_1 (lam f_2 z_1))) + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/even3/even3.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc new file mode 100644 index 00000000..cf278d92 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc @@ -0,0 +1,416 @@ +(program + 1.0.0 + [ + [ + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force (delay (lam s_1 [ s_1 s_1 ]))) + (lam + s_3 + (lam + x_4 + [ + [ + f_2 + [ + (force (delay (lam s_1 [ s_1 s_1 ]))) + s_3 + ] + ] + x_4 + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec_3 + (lam + z_4 + (lam + xs_5 + [ + [ (force xs_5) z_4 ] + (lam + x_6 + (lam + xs'_7 [ [ rec_3 [ [ f_2 z_4 ] x_6 ] ] xs'_7 ] + ) + ) + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + (lam + acc_0 + (lam + n_1 + [ + [ (builtin addInteger) acc_0 ] + [ + [ + [ + (force + (delay + (lam + f_1 + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force (delay (lam s_1 [ s_1 s_1 ]))) + (lam + s_3 + (lam + x_4 + [ + [ + f_2 + [ + (force + (delay + (lam s_1 [ s_1 s_1 ]) + ) + ) + s_3 + ] + ] + x_4 + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec_2 + (lam + z_3 + (lam + n_4 + [ + [ (force n_4) z_3 ] + (lam n'_5 [ [ rec_2 [ f_1 z_3 ] ] n'_5 ]) + ] + ) + ) + ) + ] + ) + ) + ) + [ (builtin addInteger) (con integer 1) ] + ] + (con integer 0) + ] + n_1 + ] + ] + ) + ) + ] + (con integer 0) + ] + [ + [ + (force + [ + (force + (force + (force + (force + (delay + (delay + (delay + (delay + (lam + f_7 + [ + [ + (force + (delay + (lam + by_1 + [ + (force + (force + (delay + (delay + (lam + f_2 + [ + (force + (delay + (lam s_1 [ s_1 s_1 ]) + ) + ) + (lam + s_3 + (lam + x_4 + [ + [ + f_2 + [ + (force + (delay + (lam + s_1 + [ + s_1 s_1 + ] + ) + ) + ) + s_3 + ] + ] + x_4 + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec_8 + (lam + h_11 + (delay + (lam + fr_14 + [ + (force + [ + by_1 + (delay + (lam + fq_16 + [ + (force + [ rec_8 h_11 ] + ) + [ + (force h_11) + fq_16 + ] + ] + ) + ) + ] + ) + fr_14 + ] + ) + ) + ) + ) + ] + ) + ) + ) + (lam + k_9 + (delay + (lam + h_12 + [ + [ + h_12 + (lam + x_15 + [ + (force k_9) + (lam + f_0_13 + (lam f_1_14 [ f_0_13 x_15 ]) + ) + ] + ) + ] + (lam + x_18 + [ + (force k_9) + (lam + f_0_16 + (lam f_1_17 [ f_1_17 x_18 ]) + ) + ] + ) + ] + ) + ) + ) + ] + f_7 + ] + ) + ) + ) + ) + ) + ) + ) + ) + ) + (delay + (lam + choose_9 + (lam + even_0 + (lam + odd_1 + [ + [ + choose_9 + (lam + l_4 + [ + [ + (force l_4) + (force (delay (delay (lam z_2 (lam f_3 z_2))))) + ] + (lam + head_2 + (lam + tail_3 + [ + [ + (force + (delay + (lam + x_1 + (lam + xs_2 + (delay + (lam + z_4 + (lam f_5 [ [ f_5 x_1 ] xs_2 ]) + ) + ) + ) + ) + ) + ) + head_2 + ] + [ odd_1 tail_3 ] + ] + ) + ) + ] + ) + ] + (lam + l_7 + [ + [ + (force l_7) + (force (delay (delay (lam z_2 (lam f_3 z_2))))) + ] + (lam head_5 (lam tail_6 [ even_0 tail_6 ])) + ] + ) + ] + ) + ) + ) + ) + ] + ) + (lam arg_0_0 (lam arg_1_1 arg_0_0)) + ] + [ + [ + (force + (delay + (lam + x_1 (lam xs_2 (delay (lam z_4 (lam f_5 [ [ f_5 x_1 ] xs_2 ])))) + ) + ) + ) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + (delay (lam z_1 (lam f_2 z_1))) + ] + ] + [ + [ + (force + (delay + (lam + x_1 + (lam xs_2 (delay (lam z_4 (lam f_5 [ [ f_5 x_1 ] xs_2 ])))) + ) + ) + ) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + (delay (lam z_1 (lam f_2 z_1))) + ] + ] + ] + [ + [ + (force + (delay + (lam + x_1 + (lam xs_2 (delay (lam z_4 (lam f_5 [ [ f_5 x_1 ] xs_2 ])))) + ) + ) + ) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + [ + (lam n_0 (delay (lam z_2 (lam f_3 [ f_3 n_0 ])))) + (delay (lam z_1 (lam f_2 z_1))) + ] + ] + ] + ] + (force (delay (delay (lam z_2 (lam f_3 z_2))))) + ] + ] + ] + ] + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/evenList/evenList.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc new file mode 100644 index 00000000..2f90c3ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc @@ -0,0 +1,184 @@ +(program + 1.0.0 + [ + (lam + i + [ + [ + [ + (force + (force + (delay + (delay + (lam + f + [ + (force + (force + (delay + (delay + (lam + f + [ + (force (delay (lam s [ s s ]))) + (lam + s + (lam + x + [ + [ + f + [ + (force (delay (lam s [ s s ]))) s + ] + ] + x + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec + (lam + z + (lam + xs + [ + [ (force xs) z ] + (lam x (lam xs' [ [ rec [ [ f z ] x ] ] xs' ])) + ] + ) + ) + ) + ] + ) + ) + ) + ) + ) + (builtin multiplyInteger) + ] + (con integer 1) + ] + [ + [ + (lam + n + (lam + m + [ + [ + (force + (force + (delay + (delay + (lam + f + [ + (force (delay (lam s [ s s ]))) + (lam + s + (lam + x + [ + [ + f [ (force (delay (lam s [ s s ]))) s ] + ] + x + ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec + (lam + n' + [ + [ + [ + (force + (delay + (lam + b + (lam + x + (lam + y + [ + [ + [ + [ (force (builtin ifThenElse)) b ] + x + ] + y + ] + (con unit ()) + ] + ) + ) + ) + ) + ) + [ [ (builtin lessThanEqualsInteger) n' ] m ] + ] + (lam + u + [ + [ + (force + (delay + (lam + x + (lam + xs + (delay (lam z (lam f [ [ f x ] xs ]))) + ) + ) + ) + ) + n' + ] + [ + rec + [ + (lam + i + [ + [ (builtin addInteger) i ] + (con integer 1) + ] + ) + n' + ] + ] + ] + ) + ] + (lam u (force (delay (delay (lam z (lam f z)))))) + ] + ) + ) + ] + n + ] + ) + ) + (con integer 1) + ] + i + ] + ] + ) + (con integer 4) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc.expected new file mode 100644 index 00000000..60f178c4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/factorial/factorial.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 24)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc new file mode 100644 index 00000000..b1683917 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc @@ -0,0 +1,77 @@ +(program + 1.0.0 + [ + (lam + i0 + [ + [ + (force + (force + (delay + (delay + (lam + f + [ + (force (delay (lam s [ s s ]))) + (lam + s + (lam + x [ [ f [ (force (delay (lam s [ s s ]))) s ] ] x ] + ) + ) + ] + ) + ) + ) + ) + ) + (lam + rec + (lam + i + [ + [ + [ + (force + (delay + (lam + b + (lam + x + (lam + y + [ + [ [ [ (force (builtin ifThenElse)) b ] x ] y ] + (con unit ()) + ] + ) + ) + ) + ) + ) + [ [ (builtin lessThanEqualsInteger) i ] (con integer 1) ] + ] + (lam u i) + ] + (lam + u + [ + [ + (builtin addInteger) + [ + rec [ [ (builtin subtractInteger) i ] (con integer 1) ] + ] + ] + [ rec [ [ (builtin subtractInteger) i ] (con integer 2) ] ] + ] + ) + ] + ) + ) + ] + i0 + ] + ) + (con integer 0) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/fibonacci/fibonacci.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc new file mode 100644 index 00000000..8e096832 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc @@ -0,0 +1 @@ +(program 1.0.0 (lam x (force x))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc.expected new file mode 100644 index 00000000..6e605a6a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/force-lam/force-lam.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 (force x-0))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc new file mode 100644 index 00000000..6ed2b6f6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc @@ -0,0 +1,19 @@ +(program + 1.0.0 + [ + [ + [ + [ + [ + (force (builtin ifThenElse)) + [ [ (builtin lessThanInteger) (con integer 1) ] (con integer 3) ] + ] + (builtin addInteger) + ] + (builtin subtractInteger) + ] + (con integer 1) + ] + (con integer 3) + ] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/overapplication/overapplication.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc new file mode 100644 index 00000000..036d9af1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc @@ -0,0 +1 @@ +(program 1.0.0 (lam i [ [ (builtin addInteger) i ] (con integer 1) ])) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc.expected new file mode 100644 index 00000000..46b269f6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/example/succInteger/succInteger.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam i-0 [ [ (builtin addInteger) i-0 ] (con integer 1) ])) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc new file mode 100644 index 00000000..3fdc38c6 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(lam x x) (con unit ())]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc.expected new file mode 100644 index 00000000..10b621b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-1/app-1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con unit ())) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc new file mode 100644 index 00000000..0da7f8a4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(lam x x) (con integer 0)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc.expected new file mode 100644 index 00000000..87e0223f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-2/app-2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc new file mode 100644 index 00000000..2ce0b3cc --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (con bool False)) (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-3/app-3.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc new file mode 100644 index 00000000..6af5c82a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x x) (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc.expected new file mode 100644 index 00000000..864f897c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-4/app-4.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc new file mode 100644 index 00000000..c6650881 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [[(lam x x) (lam y y)] (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc.expected new file mode 100644 index 00000000..864f897c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-5/app-5.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc new file mode 100644 index 00000000..3f1d2b8d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x x) (lam y y)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc.expected new file mode 100644 index 00000000..22488bdf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-6/app-6.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam y-0 y-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc new file mode 100644 index 00000000..7a51dad8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (lam y x)) (con integer 42)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc.expected new file mode 100644 index 00000000..46bb8bed --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-7/app-7.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam y-0 (con integer 42))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc new file mode 100644 index 00000000..be6b2e9c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (lam y x)) (con integer 42) (con bool False)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc.expected new file mode 100644 index 00000000..864f897c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-8/app-8.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc new file mode 100644 index 00000000..377c1737 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam f (lam x (lam y [f x y]))) (lam a (lam b a)) (con bool False) (con bool True)] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc.expected new file mode 100644 index 00000000..3ee9f07f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/app/app-9/app-9.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc new file mode 100644 index 00000000..30669c97 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc @@ -0,0 +1,2 @@ +-- addInteger is monomorphic so it must not be forced +(program 1.0.0 [(force (builtin addInteger)) (con integer 5) (con integer 6)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/argExpected/argExpected.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc new file mode 100644 index 00000000..a08de31c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc @@ -0,0 +1,4 @@ +-- select first branch +(program 1.1.0 + (case (constr 0 (con integer 0)) (lam x (con integer 1)) (lam x (con integer 2))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-01/case-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc new file mode 100644 index 00000000..b9861165 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc @@ -0,0 +1,4 @@ +-- select second branch +(program 1.1.0 + (case (constr 1 (con integer 0)) (lam x (con integer 1)) (lam x (con integer 2))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc.expected new file mode 100644 index 00000000..2b513f80 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-02/case-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 2)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc new file mode 100644 index 00000000..a4399f95 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc @@ -0,0 +1,4 @@ +-- select first branch and do computation with the args +(program 1.1.0 + (case (constr 0 (con integer 3) (con integer 2)) (lam x (lam y [(builtin addInteger) x y])) (lam x (lam y [(builtin subtractInteger) x y]))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc.expected new file mode 100644 index 00000000..307ccca4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-03/case-03.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 5)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc new file mode 100644 index 00000000..e471f4ec --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc @@ -0,0 +1,4 @@ +-- select second branch and do computation with the args +(program 1.1.0 + (case (constr 1 (con integer 3) (con integer 2)) (lam x (lam y [(builtin addInteger) x y])) (lam x (lam y [(builtin subtractInteger) x y]))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-04/case-04.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc new file mode 100644 index 00000000..886cca67 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc @@ -0,0 +1,4 @@ +-- case of non-constr +(program 1.1.0 + (case (lam x x) (lam x x) (lam x x)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-05/case-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc new file mode 100644 index 00000000..2d400a90 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc @@ -0,0 +1,4 @@ +-- branch with wrong arguments +(program 1.1.0 + (case (constr 0 (con integer 0)) (con integer 1) (lam x (con integer 2))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-06/case-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc new file mode 100644 index 00000000..94153d58 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc @@ -0,0 +1,4 @@ +-- case can't be used before 1.1.0 +(program 1.0.0 + (case (con integer 1)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-07/case-07.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc new file mode 100644 index 00000000..5aae469b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc @@ -0,0 +1,4 @@ +-- nullary case +(program 1.1.0 + (case (constr 0) (con integer 1) (con integer 2)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-08/case-08.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc new file mode 100644 index 00000000..bc4fcdbf --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc @@ -0,0 +1,5 @@ +-- It's legal to have a case term with no branches, but using it to branch on +-- any `constr` term will cause an error, so this will fail. +(program 1.1.0 + (case (constr 0)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-09/case-09.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc new file mode 100644 index 00000000..9f24cb5d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc @@ -0,0 +1,6 @@ +-- This should not fail: a case expression with an empty list of branches is +-- legal (but attempting to use it to branch on any `constr` term will cause an +-- error). +(program 1.1.0 + (lam x (case x)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc.expected new file mode 100644 index 00000000..4081f8b0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/case/case-10/case-10.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (lam x-0 (case x-0))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc new file mode 100644 index 00000000..ece5f5b5 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc @@ -0,0 +1 @@ +(program 1.0.0 [ (lam i_0 (lam j_1 i_0)) (con integer 1) ]) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc.expected new file mode 100644 index 00000000..96f9a133 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/closure/closure.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam j_1-0 (con integer 1))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc new file mode 100644 index 00000000..d976f70a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc @@ -0,0 +1,4 @@ +-- case on false +(program 1.1.0 + (case (con bool False) (con integer 0) (con integer 1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc.expected new file mode 100644 index 00000000..dc82b45b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-01/bool-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc new file mode 100644 index 00000000..8e69b8ba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc @@ -0,0 +1,4 @@ +-- case on true +(program 1.1.0 + (case (con bool True) (con integer 0) (con integer 1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-02/bool-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc new file mode 100644 index 00000000..ba119be8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc @@ -0,0 +1,4 @@ +-- case on false, one branch +(program 1.1.0 + (case (con bool False) (con integer 0)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc.expected new file mode 100644 index 00000000..dc82b45b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-03/bool-03.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc new file mode 100644 index 00000000..e4a51cc9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc @@ -0,0 +1,4 @@ +-- case on true, one branch. Fails +(program 1.1.0 + (case (con bool True) (con integer 0)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-04/bool-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc new file mode 100644 index 00000000..b018bc92 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc @@ -0,0 +1,4 @@ +-- case on False with 3+ branches fails +(program 1.1.0 + (case (con bool False) (con integer 0) (con integer 1) (con integer 2)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-05/bool-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc new file mode 100644 index 00000000..2cd60e0a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc @@ -0,0 +1,4 @@ +-- case on True with 3+ branches fails +(program 1.1.0 + (case (con bool True) (con integer 0) (con integer 1) (con integer 2)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-06/bool-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc new file mode 100644 index 00000000..e3473161 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc @@ -0,0 +1,4 @@ +-- case on boolean with no branches fails +(program 1.1.0 + (case (con bool False)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/bool/bool-07/bool-07.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc new file mode 100644 index 00000000..f90efcd1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc @@ -0,0 +1,4 @@ +-- case on integer with no cases fails +(program 1.1.0 + (case (con integer 0)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-01/integer-01.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc new file mode 100644 index 00000000..5e4a706d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc @@ -0,0 +1,4 @@ +-- case on integer second branch +(program 1.1.0 + (case (con integer 1) (con integer 42) (con integer 43) (con integer 443)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc.expected new file mode 100644 index 00000000..93ad0401 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-02/integer-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 43)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc new file mode 100644 index 00000000..97804300 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc @@ -0,0 +1,4 @@ +-- case on integer fails when given integer is bigger than number of branches given +(program 1.1.0 + (case (con integer 3) (con integer 42) (con integer 43) (con integer 44)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-03/integer-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc new file mode 100644 index 00000000..2934de51 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc @@ -0,0 +1,4 @@ +-- case on negative integer fails +(program 1.1.0 + (case (con integer -1) (con integer 42) (con integer 43) (con integer 44)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/integer/integer-04/integer-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc new file mode 100644 index 00000000..4e502c79 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc @@ -0,0 +1,4 @@ +-- case on non-empty list with two branches +(program 1.1.0 + (case (con (list integer) [1, 2, 3, 4]) (lam x (lam xs x)) (con integer -1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-01/list-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc new file mode 100644 index 00000000..3b05e09c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc @@ -0,0 +1,4 @@ +-- case on empty list with two branches +(program 1.1.0 + (case (con (list integer) []) (lam x (lam xs x)) (con integer -1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc.expected new file mode 100644 index 00000000..73854f9c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-02/list-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer -1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc new file mode 100644 index 00000000..c57d0141 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc @@ -0,0 +1,4 @@ +-- case on non-empty list with one branch +(program 1.1.0 + (case (con (list integer) [1, 2, 3, 4]) (lam x (lam xs x))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc.expected new file mode 100644 index 00000000..c897a619 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-03/list-03.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 1)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc new file mode 100644 index 00000000..ad2b0f8f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc @@ -0,0 +1,4 @@ +-- case on empty list with one branch +(program 1.1.0 + (case (con (list integer) []) (lam x (lam xs x))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-04/list-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc new file mode 100644 index 00000000..0afdd697 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc @@ -0,0 +1,4 @@ +-- case on non-empty list with one incorrectly typed branch +(program 1.1.0 + (case (con (list integer) [1, 2, 3, 4]) (con integer -1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-05/list-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc new file mode 100644 index 00000000..fc17e9ba --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc @@ -0,0 +1,4 @@ +-- case on non-empty list with two incorrectly typed branch +(program 1.1.0 + (case (con (list integer) [1, 2, 3, 4]) (con integer -1) (con integer -1)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-06/list-06.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc new file mode 100644 index 00000000..5c94e876 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc @@ -0,0 +1,4 @@ +-- case on empty list with two incorrectly typed branch +(program 1.1.0 + (case (con (list integer) [1, 2, 3, 4]) (con integer -1) (lam x (lam xs x))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/list/list-07/list-07.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc new file mode 100644 index 00000000..f6077321 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc @@ -0,0 +1,3 @@ +(program 1.1.0 + (case (con (pair integer bool) (42, False)) (lam l (lam r l))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc.expected new file mode 100644 index 00000000..a54d00b2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-01/pair-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc new file mode 100644 index 00000000..111a1eec --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc @@ -0,0 +1,3 @@ +(program 1.1.0 + (case (con (pair integer bool) (42, False)) (lam l (lam r r))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc.expected new file mode 100644 index 00000000..e40b7cc8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-02/pair-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con bool False)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc new file mode 100644 index 00000000..838b0dc1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc @@ -0,0 +1,4 @@ +-- Casing on pair expects exactly one branch +(program 1.1.0 + (case (con (pair integer bool) (42, False))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-03/pair-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc new file mode 100644 index 00000000..47802b76 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc @@ -0,0 +1,4 @@ +-- Casing on pair expects exactly one branch +(program 1.1.0 + (case (con (pair integer bool) (42, False)) (lam l (lam r r)) (lam l (lam r r))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-04/pair-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc new file mode 100644 index 00000000..80e5ecd1 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc @@ -0,0 +1,4 @@ +-- Casing on pair expects branch to take two arguments +(program 1.1.0 + (case (con (pair integer bool) (42, False)) (lam l l)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/pair/pair-05/pair-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc new file mode 100644 index 00000000..b885bdcb --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc @@ -0,0 +1,3 @@ +(program 1.1.0 + (case (con unit ()) (con integer 42)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc.expected new file mode 100644 index 00000000..a54d00b2 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-01/unit-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (con integer 42)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc new file mode 100644 index 00000000..f6bde45a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc @@ -0,0 +1,4 @@ +-- casing constant only expects one branch +(program 1.1.0 + (case (con unit ())) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-02/unit-02.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc new file mode 100644 index 00000000..f1fe7a84 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc @@ -0,0 +1,4 @@ +-- casing constant only expects one branch +(program 1.1.0 + (case (con unit ()) (con integer 42) (con integer 43)) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constant-case/unit/unit-03/unit-03.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc new file mode 100644 index 00000000..9c413fa7 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc @@ -0,0 +1,4 @@ +-- empty constr +(program 1.1.0 + (constr 0 ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc.expected new file mode 100644 index 00000000..a65a6aca --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-01/constr-01.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (constr 0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc new file mode 100644 index 00000000..a27c1c66 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc @@ -0,0 +1,4 @@ +-- constr with an argument +(program 1.1.0 + (constr 0 (con integer 1)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc.expected new file mode 100644 index 00000000..fafd655d --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-02/constr-02.uplc.expected @@ -0,0 +1 @@ +(program 1.1.0 (constr 0 (con integer 1))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc new file mode 100644 index 00000000..03932fb8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc @@ -0,0 +1,4 @@ +-- constr can have arbitrary terms in it +(program 1.1.0 + (constr 1 (con integer 1) (lam x x) (constr 0 (con integer 1))) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc.expected new file mode 100644 index 00000000..a22e9632 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-03/constr-03.uplc.expected @@ -0,0 +1,3 @@ +(program + 1.1.0 (constr 1 (con integer 1) (lam x-0 x-0) (constr 0 (con integer 1))) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc new file mode 100644 index 00000000..106cc268 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc @@ -0,0 +1,4 @@ +-- constr is strict in all its arguments +(program 1.1.0 + (constr 0 (error)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-04/constr-04.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc new file mode 100644 index 00000000..f82ce4c8 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc @@ -0,0 +1,4 @@ +-- constr is strict in all its arguments +(program 1.1.0 + (constr 50000 (con integer 1) (error)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-05/constr-05.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc new file mode 100644 index 00000000..cc13663b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc @@ -0,0 +1,4 @@ +-- constr can't be used before 1.1.0 +(program 1.0.0 + (constr 0 ) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-06/constr-06.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc new file mode 100644 index 00000000..da516a75 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc @@ -0,0 +1,4 @@ +-- negative tags are not allowed +(program 1.1.0 + (constr -5 (con integer 1) (error)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-07/constr-07.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc new file mode 100644 index 00000000..c92c7a9f --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc @@ -0,0 +1,4 @@ +-- Tag can be as large as 2^64-1 = maxBound :: Word64 +(program 1.1.0 + (constr 18446744073709551615 (con string "Maximum tag = 2^64-1") (con integer 999)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc.expected new file mode 100644 index 00000000..ce2dd4d9 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-08/constr-08.uplc.expected @@ -0,0 +1,6 @@ +(program + 1.1.0 + (constr + 18446744073709551615 (con string "Maximum tag = 2^64-1") (con integer 999) + ) +) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc new file mode 100644 index 00000000..31f62f84 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc @@ -0,0 +1,4 @@ +-- Tag cannot exceeed 2^64-1 = maxBound :: Word64 +(program 1.1.0 + (constr 18446744073709551616 (con string "Maximum tag plus one") (con unit ())) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-09/constr-09.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc new file mode 100644 index 00000000..c8acb131 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc @@ -0,0 +1,4 @@ +-- Version check fails before tag check +(program 1.0.0 + (constr 18446744073709551616 (con string "Maximum tag plus one") (con unit ())) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc.expected new file mode 100644 index 00000000..fd569489 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/constr/constr-10/constr-10.uplc.expected @@ -0,0 +1 @@ +parse error \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc new file mode 100644 index 00000000..cdb6cecd --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (con integer 4)) (delay (error))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-1/delay-error-1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc new file mode 100644 index 00000000..c66a7e76 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x x) (delay (error))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc.expected new file mode 100644 index 00000000..7a1e6b24 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-error-2/delay-error-2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (delay (error))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc new file mode 100644 index 00000000..53caa7da --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc @@ -0,0 +1 @@ +(program 1.0.0 (lam x (delay x))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc.expected new file mode 100644 index 00000000..0f973958 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/delay/delay-lam/delay-lam.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 (delay x-0))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc new file mode 100644 index 00000000..c18ae365 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc @@ -0,0 +1,2 @@ +-- can only force a delay or a forceable (polymorphic) builtin +(program 1.0.0 (force (con integer 5))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-1/force-1.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc new file mode 100644 index 00000000..2242bd8a --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (force x)) (delay (con integer 4))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-2/force-2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc new file mode 100644 index 00000000..faec27e0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + [(lam x (force [(lam y y) x])) (delay (con integer 4))] +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc.expected new file mode 100644 index 00000000..68ab9fd0 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-3/force-3.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (con integer 4)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc new file mode 100644 index 00000000..c7b2c594 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (force (lam x x)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/force/force-4/force-4.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc new file mode 100644 index 00000000..b4f6fd5c --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc @@ -0,0 +1 @@ +(program 1.0.0 (lam x x)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc.expected new file mode 100644 index 00000000..4b120840 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-1/lam-1.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 x-0)) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc new file mode 100644 index 00000000..3cd7e867 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc @@ -0,0 +1,3 @@ +(program 1.0.0 + (lam x (con integer 23)) +) diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc.expected new file mode 100644 index 00000000..a03a2f92 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/lam/lam-2/lam-2.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 (lam x-0 (con integer 23))) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc new file mode 100644 index 00000000..c2d797db --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc @@ -0,0 +1 @@ +(program 1.0.0 [(con integer 3) (con integer 4)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/nonFunctionalApplication/nonFunctionalApplication.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc new file mode 100644 index 00000000..e0450e29 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc @@ -0,0 +1,2 @@ +-- ill-typed. This fails at runtime since the builtin application is saturated. +(program 1.0.0 [(builtin addInteger) (con unit ()) (con integer 3)]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-sat/unlifting-sat.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc new file mode 100644 index 00000000..ce2efb7b --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc @@ -0,0 +1,2 @@ +-- ill-typed but does not fail at runtime because the builtin application is not saturated. +(program 1.0.0 [(builtin addInteger) (con unit ())]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc.expected new file mode 100644 index 00000000..57d2ddd4 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/unlifting-unsat/unlifting-unsat.uplc.expected @@ -0,0 +1 @@ +(program 1.0.0 [ (builtin addInteger) (con unit ()) ]) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc new file mode 100644 index 00000000..7a343083 --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc @@ -0,0 +1 @@ +(program 1.0.0 x) \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc.expected b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc.expected new file mode 100644 index 00000000..ccc477ff --- /dev/null +++ b/demos/uplc-jvm/src/test/resources/plutus-conformance/uplc/evaluation/term/var/var.uplc.expected @@ -0,0 +1 @@ +evaluation failure \ No newline at end of file diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/CompilerSpec.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/CompilerSpec.scala new file mode 100644 index 00000000..03cd1dcf --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/CompilerSpec.scala @@ -0,0 +1,123 @@ +package dev.constructive.eo.demo.uplc + +import dev.constructive.eo.demo.uplc.Oracle.Verdict +import org.specs2.mutable.Specification +import scalus.cardano.ledger.Word64 +import scalus.uplc.{Constant, DeBruijn, DefaultFun, NamedDeBruijn, Program, Term} + +/** Hand-written programs, one per compilation path, each checked against the CEK machine. */ +class CompilerSpec extends Specification: + + private def term(uplc: String): Term = + DeBruijn.deBruijnTerm(Program.parseUplc(s"(program 1.1.0 $uplc)").fold(sys.error, _.term)) + + private def agrees(program: Term | String, expected: Option[String]) = + val script = program match + case t: Term => Oracle.script(t) + case s: String => Oracle.script(s) + Oracle.compare(script) must beLike { + case Verdict.BothSucceed(t) if expected.nonEmpty => t.α_==(term(expected.get)) must beTrue + case Verdict.BothFail(_, _) if expected.isEmpty => ok + } + + private def yields(uplc: String, expected: String) = agrees(uplc, Some(expected)) + private def fails(program: Term | String) = agrees(program, None) + + "the UPLC → JVM translation agrees with the CEK machine on" >> { + "let-bound integer arithmetic (typed fast path)" >> yields( + "[(lam x [(builtin addInteger) x (con integer 1)]) (con integer 41)]", + "(con integer 42)" + ) + "a multi-binding let whose right-hand sides see only the outer scope" >> yields( + "[(lam a [(lam x (lam y [(builtin subtractInteger) x y])) (con integer 10) a]) (con integer 3)]", + "(con integer 7)" + ) + "if-then-else over delayed branches" >> yields( + "(force [(force (builtin ifThenElse)) [(builtin lessThanInteger) (con integer 1) (con integer 2)] (delay (con string \"yes\")) (delay (error))])", + "(con string \"yes\")" + ) + "a closure returned as the result (discharge substitutes captures)" >> + yields("[(lam x (lam y x)) (con integer 5)]", "(lam y (con integer 5))") + "a partially applied lambda chain" >> yields( + "[(lam x (lam y (lam z [(builtin addInteger) x z]))) (con integer 1)]", + "(lam y (lam z [(builtin addInteger) (con integer 1) z]))" + ) + "a partially applied builtin" >> + yields("[(builtin addInteger) (con integer 1)]", "[(builtin addInteger) (con integer 1)]") + "a forced polymorphic builtin" >> + yields("(force (builtin ifThenElse))", "(force (builtin ifThenElse))") + "a builtin applied as a value, through its CEK meaning" >> yields( + "[(lam f [f (con bool True) (con integer 1) (lam x x)]) (force (builtin ifThenElse))]", + "(con integer 1)" + ) + "constr / case with a lambda branch" >> yields( + "(case (constr 1 (con integer 2) (con integer 3)) (lam a a) (lam a (lam b [(builtin multiplyInteger) a b])))", + "(con integer 6)" + ) + "case whose branch takes more fields than given (partial result)" >> yields( + "(case (constr 0 (con integer 2) (con integer 3)) (lam a (lam b (lam c a))))", + "(lam c (con integer 2))" + ) + "case whose branch is not a lambda (fields first, then the branch)" >> yields( + "(case (constr 0 (con integer 2) (con integer 3)) [(lam f f) (builtin addInteger)])", + "(con integer 5)" + ) + "case whose branch takes fewer fields than given" >> + fails("(case (constr 0 (con integer 2) (con integer 3)) (lam a a))") + "case on an integer (PV11)" >> yields( + "(case (con integer 1) (con string \"zero\") (con string \"one\"))", + "(con string \"one\")" + ) + "case on a boolean (PV11)" >> yields( + "(case [(builtin equalsInteger) (con integer 1) (con integer 1)] (con integer 0) (con integer 1))", + "(con integer 1)" + ) + "case on a list (PV11)" >> + yields( + "(case (con (list integer) [7, 8]) (lam h (lam t h)) (con integer 0))", + "(con integer 7)" + ) + "recursion through a Z combinator" >> { + val z = "(lam f [(lam x [f (lam v [x x v])]) (lam x [f (lam v [x x v])])])" + val fact = + "(lam self (lam n (force [(force (builtin ifThenElse)) [(builtin lessThanEqualsInteger) n (con integer 0)] (delay (con integer 1)) (delay [(builtin multiplyInteger) n [self [(builtin subtractInteger) n (con integer 1)]]])])))" + yields(s"[[$z $fact] (con integer 20)]", "(con integer 2432902008176640000)") + } + "a crypto builtin (sha2_256)" >> yields( + "[(builtin lengthOfByteString) [(builtin sha2_256) (con bytestring #00ff)]]", + "(con integer 32)" + ) + "data builtins and chooseData over delays" >> yields( + "(force [(force (builtin chooseData)) (con data (I 5)) (delay (con integer 0)) (delay (con integer 1)) (delay (con integer 2)) (delay [(builtin unIData) (con data (I 5))]) (delay (con integer 4))])", + "(con integer 5)" + ) + "trace" >> + yields("[(force (builtin trace)) (con string \"hello\") (con unit ())]", "(con unit ())") + "error" >> fails("(error)") + "division by zero on the typed path" >> + fails("[(builtin divideInteger) (con integer 1) (con integer 0)]") + "a type error on the typed path" >> + fails("[(builtin addInteger) (con integer 1) (con string \"one\")]") + "applying a non-function" >> fails("[(con integer 1) (con integer 2)]") + "forcing a builtin that wants an argument" >> fails("(force (builtin addInteger))") + "case on a constructor without a branch" >> fails("(case (constr 2) (con integer 0))") + // The ledger's scope check skips case/constr bodies, so open terms do reach evaluation. + "an unbound variable that is evaluated" >> + fails(Term.Case(Term.Constr(Word64(0), Nil), List(Term.Var(NamedDeBruijn("free", 7))))) + } + + "large programs: a 20 000-deep let chain still fits the JVM's 64 KB method limit" >> { + // let x1 = x0 + 1 in let x2 = x1 + 1 in … — the layout compilers give top-level helpers. + // Built as a term (Scalus' text parser recurses too deeply for it), de Bruijn throughout. + val (x, one) = (Term.Var(NamedDeBruijn("x", 1)), Term.Const(Constant.Integer(1))) + val next = Term.Apply(Term.Apply(Term.Builtin(DefaultFun.AddInteger), x), one) + val chain = + (1 to 20000).foldLeft[Term](x)((body, _) => Term.Apply(Term.LamAbs("x", body), next)) + val program = Term.Apply(Term.LamAbs("x", chain), Term.Const(Constant.Integer(0))) + // Compiling is stack safe; Scalus' flat encoder and decoder, which the harness runs, recurse. + Exec.onLargeStack(agrees(program, Some("(con integer 20000)"))) + } + + "malformed bytes are rejected as a value, not an exception" >> { + CborScript.parse(Array[Byte](1, 2, 3)) must beLeft + } diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ConformanceSpec.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ConformanceSpec.scala new file mode 100644 index 00000000..47e64706 --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ConformanceSpec.scala @@ -0,0 +1,56 @@ +package dev.constructive.eo.demo.uplc + +import scala.jdk.CollectionConverters.* + +import dev.constructive.eo.demo.uplc.Oracle.Verdict +import java.nio.charset.StandardCharsets.UTF_8 +import java.nio.file.{Files, Path, Paths} +import org.specs2.execute.{Result, Skipped} +import org.specs2.mutable.Specification +import org.specs2.specification.core.Fragment +import scalus.uplc.Program + +/** The Plutus conformance suite (vendored, see `plutus-conformance/SOURCE.md`) as a differential + * test: each program is flat-encoded, translated to a class file, run, and compared with what the + * Scalus CEK machine computes for the same flat bytes. + * + * The `.expected` files are used for one thing only: to check the comparison is not vacuous. A + * case the suite expects to succeed must succeed on both sides, and one it expects to fail must + * fail on both — so a broken harness cannot pass by having both evaluators fail everything. + */ +class ConformanceSpec extends Specification: + + private val root: Path = + Paths.get(getClass.getResource("/plutus-conformance/uplc/evaluation").toURI) + + private val cases: List[Path] = + Files.walk(root).iterator.asScala.filter(_.toString.endsWith(".uplc")).toList.sortBy(_.toString) + + private def read(p: Path): String = new String(Files.readAllBytes(p), UTF_8).trim + + private def check(file: Path): Result = + val expected = read(Paths.get(file.toString + ".expected")) + if expected == "parse error" then Skipped("a parser test, not an evaluation") + else + Program.parseUplc(read(file)) match + case Left(e) => Skipped(s"Scalus cannot parse it: ${e.linesIterator.nextOption()}") + case Right(program) => + CborScript.of(program) match + case Left(e) => Skipped(e) + case Right(script) => + val expectFailure = expected == "evaluation failure" + Oracle.compare(script) match + case Verdict.Disagree(detail) => failure(detail) + case Verdict.BothSucceed(t) if expectFailure => + failure(s"both evaluators succeeded with ${t.show}, the suite expects failure") + case Verdict.BothFail(jvm, cek) if !expectFailure => + failure( + s"both evaluators failed (JVM: $jvm; CEK: $cek), the suite expects $expected" + ) + case _ => success + + s"Plutus conformance (${cases.size} UPLC evaluation cases): the JVM class agrees with the CEK machine" >> { + Fragment.foreach(cases)(file => + root.relativize(file).toString.stripSuffix(".uplc") >> check(file) + ) + } diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Demo.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Demo.scala new file mode 100644 index 00000000..da7b5b51 --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Demo.scala @@ -0,0 +1,85 @@ +package dev.constructive.eo.demo.uplc + +import scala.jdk.CollectionConverters.* + +import dev.constructive.eo.demo.uplc.validators.{CompiledValidators, Scenarios} +import java.nio.file.{Files, Paths} +import org.objectweb.asm.util.{Textifier, TraceMethodVisitor} +import scalus.uplc.eval.Result +import scalus.uplc.{DeBruijn, DeBruijnedProgram} + +/** The round trip, stage by stage — what the docs page (`site/docs/demos/uplc-jvm.md`) shows. + * + * {{{sbt "demoUplcJvm/Test/runMain dev.constructive.eo.demo.uplc.Demo [dir-for-the-class-file]"}}} + * + * Timings live in the JMH project (`demos/uplc-jvm-bench`), not here. + */ +object Demo: + + def main(args: Array[String]): Unit = + // let x = 6 in let y = x * x in x + y, as UPLC compilers write it + val letArithmetic = + "[(lam x [(lam y [(builtin addInteger) x y]) [(builtin multiplyInteger) x x]]) (con integer 6)]" + section("A small program, all the way round", letArithmetic) + val script = parse(letArithmetic) + val typed = Oracle.typed(script) + println(s"\ntoTyped.getOption:\n${typed.body.show}") + val cls = UplcJvm.lowering.get(typed) + println(s"\nlowering.get, the method `run`:\n${bytecode(cls, "run")}") + val classFile = Oracle.classFile(script) + println(s"\ncompiling.getOption: ${classFile.bytes.length} bytes of class file") + println( + s"and back — toBytecode.reverseGet(that) == script: ${UplcJvm.toBytecode.reverseGet(classFile) == script}" + ) + args + .headOption + .foreach(dir => Files.write(Paths.get(dir, "UplcProgram.class"), classFile.bytes)) + compare(script, classFile) + + // A program whose value is a closure: it comes back as a term, captures substituted. + val closure = "[(lam x (lam y x)) (con integer 5)]" + section("A closure comes back as a term", closure) + compare(parse(closure), Oracle.classFile(parse(closure))) + + section("A Scalus-compiled validator, read back (Fibonacci)", "") + val fib = Oracle.script(CompiledValidators.fibonacci.program) + println(s"${fib.bytes.length} bytes of script\n\n${Oracle.typed(fib).body.show}") + println(s"\n${shape(fib)}") + + section("Every validator", "") + Scenarios + .accepting + .foreach(s => println(f"${s.name}%-11s ${shape(Oracle.script(s.script.program))}")) + + private def section(title: String, uplc: String): Unit = + println(s"\n=== $title ===\n${if uplc.isEmpty then "" else s"\n(program 1.1.0 $uplc)"}") + + /** Sizes: script bytes, closure body methods in the class, class-file bytes. */ + private def shape(script: CborScript): String = + val cls = Oracle.jvmClass(script) + val bodies = cls.tree.methods.asScala.count(_.name.startsWith("m")) + val classFile = Oracle.classFile(script).bytes.length + f"script ${script.bytes.length}%4d bytes class: $bodies%2d closure bodies class file ${classFile}%5d bytes" + + /** One method of a class, as ASM prints bytecode. */ + private def bytecode(cls: JvmClass, method: String): String = + val text = new Textifier + cls + .tree + .methods + .asScala + .filter(_.name == method) + .foreach(_.accept(new TraceMethodVisitor(text))) + text.getText.asScala.mkString + + private def parse(uplc: String): CborScript = Oracle.script(uplc) + + /** Runs the class, discharges its value, and puts the CEK machine's answer next to it. */ + private def compare(script: CborScript, classFile: JvmClassScript): Unit = + val cek = Semantics.vm.evaluateDeBruijnedTerm(DeBruijnedProgram.fromCbor(script.bytes).term) + Exec.run(classFile) match + case Result.Success(t, _, _, _) => + println(s"\nrun + discharge: ${DeBruijn.fromDeBruijnTerm(t).show}") + println(s"CEK machine: ${cek.show}") + println(s"α-equal: ${t.α_==(DeBruijn.deBruijnTerm(cek))}") + case Result.Failure(e, _, _, _) => println(s"\nrun failed: ${e.getMessage}") diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/OpticSpec.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/OpticSpec.scala new file mode 100644 index 00000000..1a852b12 --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/OpticSpec.scala @@ -0,0 +1,162 @@ +package dev.constructive.eo.demo.uplc + +import scala.jdk.CollectionConverters.* +import scala.util.Try + +import dev.constructive.eo.demo.uplc.validators.Scenarios +import dev.constructive.eo.laws.PrismLaws +import dev.constructive.eo.laws.discipline.PrismTests +import java.util.concurrent.FutureTask +import org.objectweb.asm.Opcodes +import org.objectweb.asm.tree.{JumpInsnNode, MethodInsnNode} +import org.scalacheck.{Arbitrary, Cogen, Gen} +import org.specs2.mutable.Specification +import org.typelevel.discipline.specs2.mutable.Discipline +import scalus.cardano.ledger.Word64 +import scalus.uplc.{Constant, DefaultFun, NamedDeBruijn, Program, Term} + +/** The optics' laws, and what hybrid typing does to real code. */ +class OpticSpec extends Specification with Discipline: + + import Oracle.script + + /** A program whose value is a closure, and every validator. The differential suites check the + * round trips on every program they run (`Oracle.compare`), the conformance suite's included. + */ + private val validators = Scenarios.accepting.map(s => script(s.script.program)) + private val scripts = script("[(lam x (lam y x)) (con integer 5)]") :: validators + + private def int(i: Int): Term = Term.Const(Constant.Integer(i)) + + /** One constructor with 5000 computed fields and no `let`: one method, over the JVM's 64 KB. */ + private val tooLarge = script( + Term.Constr( + Word64(0), + List.fill(5000)(Term.Apply(Term.Apply(Term.Builtin(DefaultFun.AddInteger), int(1)), int(2))) + ) + ) + + /** A well-formed script of a Plutus Core version no ledger knows: Scalus encodes any version. */ + private val unknown = CborScript.of(Program((2, 0, 0), int(1))).fold(sys.error, identity) + + private def tooBig(compiled: Either[String, JvmClassScript]) = + compiled.left.exists(_.startsWith("Method too large")) + + given Arbitrary[CborScript] = Arbitrary(Gen.oneOf(unknown :: tooLarge :: scripts)) + given Arbitrary[TypedProgram] = Arbitrary(Gen.oneOf(scripts).map(Oracle.typed)) + given Cogen[TypedProgram] = Cogen[Int].contramap(_.hashCode) + given Arbitrary[JvmClassScript] = Arbitrary(Gen.oneOf(scripts).map(Oracle.classFile)) + given Cogen[JvmClassScript] = Cogen[Int].contramap(c => java.util.Arrays.hashCode(c.bytes)) + + checkAll( + "UplcJvm.toTyped: CborScript ⇀ TypedProgram", + new PrismTests[CborScript, TypedProgram]: + val laws = new PrismLaws[CborScript, TypedProgram]: + val prism = UplcJvm.toTyped + .prism, + ) + checkAll( + "UplcJvm.toBytecode: CborScript ⇀ JvmClassScript", + new PrismTests[CborScript, JvmClassScript]: + val laws = new PrismLaws[CborScript, JvmClassScript]: + val prism = UplcJvm.toBytecode + .prism, + ) + + "the typer is a prism: a script of a Plutus Core version these semantics do not know has none" >> { + (UplcJvm.toTyped.getOption(unknown) must beNone) + .and(UplcJvm.toBytecode.getOption(unknown) must beNone) + } + + "the compiler is a prism: a class too large for a class file has none" >> { + (UplcJvm.toBytecode.getOption(tooLarge) must beNone) + .and(tooBig(UplcJvm.compile(Oracle.jvmClass(tooLarge))) must beTrue) + } + + "scripts, classes and class files hand out copies: changing those changes nothing" >> { + val s = scripts.head + val (classFile, cls) = (Oracle.classFile(s), Oracle.jvmClass(s)) + s.bytes(0) = 0 + classFile.bytes(10) = 0 + cls.tree.methods.clear() + (UplcJvm.toBytecode.reverseGet(classFile) must beEqualTo(s)) + .and(UplcJvm.lowering.reverseGet(cls).script must beEqualTo(s)) + .and(UplcJvm.toBytecode.getOption(s) must beEqualTo(Some(classFile))) + } + + /** `f`, on a thread with a stack of `bytes`. */ + private def onStack[A](bytes: Long)(f: => A): Either[Throwable, A] = + val task = new FutureTask[A](() => f) + val thread = new Thread(null, task, "stack", bytes) + thread.start() + thread.join() + Try(task.get()).toEither + + /** Typed, lowered and compiled on a 1 MB stack — the JVM's default for a thread. Scalus' own flat + * encoder and decoder recurse, so they get a large one. + */ + private def compiledOnSmallStack(term: Term) = + val source = onStack(1L << 30)(SourceProgram.decode(script(term))).fold(throw _, identity) + onStack(1L << 20)(UplcJvm.compile(Lower.lower(Typer.typeProgram(source)))) + + "compiling is stack safe: programs nested 100 000 deep" >> { + def nest(times: Int, inner: Term)(wrap: Term => Term) = + (1 to times).foldLeft(inner)((t, _) => wrap(t)) + "force (delay …), which the typer reads back as the constant inside: a class file" >> { + val deep = nest(100000, int(0))(t => Term.Force(Term.Delay(t))) + compiledOnSmallStack(deep).map(_.isRight) must beEqualTo(Right(true)) + } + "headList (headList …), one method of direct calls: too large for a class file" >> { + val headList = Term.Force(Term.Builtin(DefaultFun.HeadList)) + val deep = nest(100000, Term.Const(Constant.List(scalus.uplc.DefaultUni.Integer, Nil)))( + Term.Apply(headList, _) + ) + compiledOnSmallStack(deep).map(tooBig) must beEqualTo(Right(true)) + } + "λx. λx. … x, a closure per 200 lambdas: their dispatch method is too large for a class file" >> { + val deep = nest(100000, Term.Var(NamedDeBruijn("x", 100000)))(Term.LamAbs("x", _)) + compiledOnSmallStack(deep).map(tooBig) must beEqualTo(Right(true)) + } + } + + "typed reads UPLC back as a typed Scala-like expression" >> { + val a = Oracle.typed(script("[(lam x [(builtin multiplyInteger) x x]) (con integer 7)]")) + a.body.show must beEqualTo("val v0: BigInt = 7\nmultiplyInteger(v0, v0)") + } + + /** Every method call in the lowered class, as `Owner.name`. */ + private def calls(script: CborScript): Vector[String] = + val methods = Oracle.jvmClass(script).tree.methods.asScala.toVector + methods.flatMap(_.instructions.iterator.asScala.collect { + case m: MethodInsnNode => s"${m.owner.split('/').last}.${m.name}" + case j: JumpInsnNode if j.getOpcode == Opcodes.IFEQ => "if" + }) + + "hybrid typing" >> { + "keeps let-bound arithmetic unboxed end to end (the constant read once, one box at the result)" >> { + val code = calls( + script( + "[(lam x [(lam y [(builtin addInteger) x y]) [(builtin multiplyInteger) x x]]) (con integer 6)]" + ) + ) + (code.filter(_.startsWith("AbstractBuiltins.")) must beEqualTo( + Vector("AbstractBuiltins.multiplyInteger", "AbstractBuiltins.addInteger") + )) + .and(code.count(_.startsWith("Rt.box")) must beEqualTo(1)) + .and(code.filter(_.startsWith("Rt.un")) must beEqualTo(Vector("Rt.unInt"))) + } + "turns forced ifThenElse over delays into a JVM branch on a primitive boolean" >> { + val code = calls( + script( + "(force [(force (builtin ifThenElse)) [(builtin lessThanInteger) (con integer 1) (con integer 2)] (delay (con integer 1)) (delay (con integer 2))])" + ) + ) + (code.count(_ == "if") must beEqualTo(1)).and(code.count(_ == "Rt.closure") must beEqualTo(0)) + } + "finds direct builtin calls, direct closure calls and branches in Scalus-compiled validators" >> { + val code = Scenarios.accepting.flatMap(s => calls(script(s.script.program))) + (code.count(_.startsWith("AbstractBuiltins.")) must beGreaterThan(0)) + .and(code.count(_ == "Rt.envOf") must beGreaterThan(0)) + .and(code.count(c => c == "if" || c == "Rt.chooseIndex") must beGreaterThan(0)) + } + } diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Oracle.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Oracle.scala new file mode 100644 index 00000000..a05a99be --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/Oracle.scala @@ -0,0 +1,85 @@ +package dev.constructive.eo.demo.uplc + +import scala.util.control.NonFatal + +import io.bullet.borer.Cbor +import scalus.uplc.eval.{CekMachine, NoBudgetSpender, NoLogger, Result} +import scalus.uplc.{Constant, DeBruijnedProgram, Program, ProgramFlatCodec, Term} + +/** The differential harness: one script, two evaluators, one verdict. */ +object Oracle: + + /** A program the suite knows has a flat encoding; anything else fails the test. */ + def script(program: Program): CborScript = CborScript.of(program).fold(sys.error, identity) + + def script(uplc: String): CborScript = + script(Program.parseUplc(s"(program 1.1.0 $uplc)").fold(sys.error, identity)) + + /** A de Bruijn term as it is, open ones included: Scalus' only encoder that keeps a term's + * indices, rather than deriving them from names, is the unchecked `unsafeEncodeFlat`. + */ + def script(term: Term): CborScript = + val flat = ProgramFlatCodec.unsafeEncodeFlat(Program((1, 1, 0), term)) + CborScript.parse(Cbor.encode(flat).toByteArray).fold(sys.error, identity) + + /** A script's typed program, JVM class and class file. A script of an unknown Plutus Core + * version, or one too large for a class file, fails the test. + */ + def typed(script: CborScript): TypedProgram = + UplcJvm.toTyped.getOption(script).getOrElse(sys.error("an unknown Plutus Core version")) + + def jvmClass(script: CborScript): JvmClass = UplcJvm.lowering.get(typed(script)) + + def classFile(script: CborScript): JvmClassScript = + UplcJvm.compile(jvmClass(script)).fold(sys.error, identity) + + /** What the Scalus CEK machine makes of a script (then applied to `args`). */ + def cek(script: CborScript, args: Seq[Constant] = Nil): Either[String, Term] = + val program = DeBruijnedProgram.fromCbor(script.bytes) + val applied = args.foldLeft(program.term)((f, a) => Term.Apply(f, Term.Const(a))) + val machine = new CekMachine( + Semantics.vm.machineParams, + NoBudgetSpender, + NoLogger, + Semantics.runtime, + Semantics.caseOnBuiltins, + caseOnDataEnabled = Semantics.caseOnData, + ) + // The oracle's own failures are its verdict, whatever their exception class. + try Right(Exec.onLargeStack(machine.evaluateTerm(applied))) + catch case NonFatal(e) => Left(s"${e.getClass.getSimpleName}: ${e.getMessage}") + + enum Verdict: + case BothSucceed(term: Term) + case BothFail(jvm: String, cek: String) + case Disagree(detail: String) + + /** Runs `script` (applied to `args`) through the generated class and the CEK machine. A class the + * JVM's verifier rejects fails the comparison with a `VerifyError`. + */ + def compare(script: CborScript, args: Seq[Constant] = Nil): Verdict = + UplcJvm + .toJvmClass + .getOption(script) + .toRight("an unknown Plutus Core version") + .flatMap(UplcJvm.compile) match + case Left(why) => Verdict.Disagree(s"no class file: $why") + // The optics' laws, on every program: the script comes back out of its class, and the class + // file survives ASM reading it and writing it again. + case Right(classFile) => + if UplcJvm.toBytecode.reverseGet(classFile) != script || + UplcJvm.compile(UplcJvm.decompile(classFile)) != Right(classFile) + then Verdict.Disagree("the class file does not round-trip") + else compare(classFile, script, args) + + private def compare(classFile: JvmClassScript, script: CborScript, args: Seq[Constant]) = + (Exec.run(classFile, args), cek(script, args)) match + case (Result.Success(jvm, _, _, _), Right(expected)) => + if jvm.α_==(expected) then Verdict.BothSucceed(jvm) + else Verdict.Disagree(s"JVM: ${jvm.show}\nCEK: ${expected.show}") + case (Result.Failure(jvm, _, _, _), Left(expected)) => + Verdict.BothFail(jvm.getMessage, expected) + case (Result.Success(jvm, _, _, _), Left(expected)) => + Verdict.Disagree(s"JVM succeeded with ${jvm.show}\nCEK failed: $expected") + case (Result.Failure(jvm, _, _, _), Right(expected)) => + Verdict.Disagree(s"JVM failed: ${jvm.getMessage}\nCEK succeeded with ${expected.show}") diff --git a/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ValidatorSpec.scala b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ValidatorSpec.scala new file mode 100644 index 00000000..b551e71f --- /dev/null +++ b/demos/uplc-jvm/src/test/scala/dev/constructive/eo/demo/uplc/ValidatorSpec.scala @@ -0,0 +1,37 @@ +package dev.constructive.eo.demo.uplc + +import dev.constructive.eo.demo.uplc.Oracle.Verdict +import dev.constructive.eo.demo.uplc.validators.{Scenario, Scenarios} +import org.specs2.execute.Result +import org.specs2.mutable.Specification +import org.specs2.specification.core.Fragment +import scalus.uplc.{Constant, Term} + +/** Smart-contract validation, differential: validators written in Scala and compiled to UPLC by the + * Scalus plugin run against V3 script contexts through the CEK machine and through the generated + * class, for transactions they must accept and transactions they must reject. + * + * Each script is exercised two ways: + * - compiled ONCE from its on-chain form (`UplcJvm.toBytecode`) and applied to the context at + * run time — how a node would use a JIT; + * - applied to the context first and translated as a whole, the context then being one large + * embedded `Data` constant. + */ +class ValidatorSpec extends Specification: + + private def check(s: Scenario): Result = + val classFile = Oracle.classFile(Oracle.script(s.script.program)) + val verdict = Oracle.compare(Oracle.script(s.script.program $ s.context)) + // CIP-117: a V3 script validates iff it evaluates to unit. + val oracleAccepts = verdict match + case Verdict.BothSucceed(Term.Const(Constant.Unit, _)) => true + case _ => false + (verdict must not(beAnInstanceOf[Verdict.Disagree])) + .and(oracleAccepts must beEqualTo(s.accepts)) + .and(Exec.validate(classFile, s.context).isRight must beEqualTo(s.accepts)) + + "Scalus-compiled validators: the JVM class and the CEK machine reach the same verdict" >> { + Fragment.foreach(Scenarios.all) { s => + s"${s.name} — ${if s.accepts then "accepts" else "rejects"}" >> check(s) + } + } diff --git a/site/docs/benchmarks.md b/site/docs/benchmarks.md index 6e4a6dfa..00df0245 100644 --- a/site/docs/benchmarks.md +++ b/site/docs/benchmarks.md @@ -34,6 +34,10 @@ table, and for the ratios everywhere, the signal holds. > sub-nanosecond truth. See [Reproducing](#reproducing) and > [`benchmarks/README.md`](https://github.com/Constructive-Programming/eo/blob/main/benchmarks/README.md). +The [UPLC → JVM demo](demos/uplc-jvm.md) has its own JMH suite — the Scalus CEK +machine against the class files the demo compiles — reported on its page, not +here. + For the trend over time, the nightly sweep pipeline records every full run: the **[benchmark history chart](https://constructive-programming.github.io/eo/bench/index.html)** plots B/op and ns/op per benchmark across sweeps, and the latest full table is generated into diff --git a/site/docs/demos/directory.conf b/site/docs/demos/directory.conf new file mode 100644 index 00000000..7486263b --- /dev/null +++ b/site/docs/demos/directory.conf @@ -0,0 +1,4 @@ +laika.title = Demos +laika.navigationOrder = [ + uplc-jvm.md +] diff --git a/site/docs/demos/uplc-jvm.md b/site/docs/demos/uplc-jvm.md new file mode 100644 index 00000000..dcc97766 --- /dev/null +++ b/site/docs/demos/uplc-jvm.md @@ -0,0 +1,494 @@ +# UPLC → JVM bytecode + +> **A demo, not a module.** The code lives in +> [`demos/uplc-jvm`](https://github.com/Constructive-Programming/eo/tree/main/demos/uplc-jvm) +> and is not published. It shows what optics buy a real program: a +> compiler from Untyped Plutus Core (UPLC) — the language Cardano smart +> contracts run in — to JVM class files, checked against the +> [Scalus](https://scalus.org) CEK machine on every program it compiles. + +## The idea: a compiler is a chain of optics + +A compiler is usually a function: script in, class file out. It becomes an +isomorphism as soon as its output remembers its input. Here every stage keeps +the script it came from — the typed program holds its source, and the class +embeds the script in its constants — so every arrow can be walked back: + +``` +CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript + toTyped lowering compiling +``` + +The middle arrow is an iso. The other two are prisms — each walks back from +everything it reaches, but not every value has somewhere to go: + +- **`toTyped`.** A script declares the Plutus Core version it is written in, + and the bytes can name any version; Scalus decodes them all. The ledger takes + only the versions Plutus V3 has at protocol version 11 — 1.0.0 and 1.1.0, + which adds `constr` and `case` — so a script of any other version has no + typed program. +- **`compiling`.** The JVM has limits a program can exceed: a method holds at + most 64 KB of bytecode and a class at most 65 535 constants, so a class can be + too large for a class file — and then there is none. + +| type | what it is | +|---|---| +| `CborScript` | a script as the ledger stores it: the flat-encoded program in a CBOR bytestring | +| `TypedProgram` | the program read back as a typed, Scala-like expression | +| `JvmClass` | the script's JVM class in memory: [ASM](https://asm.ow2.io)'s `ClassNode` | +| `JvmClassScript` | a class file the compiler wrote | + +`CborScript` and `JvmClassScript` are opaque types over Scalus' `ByteString`, so +the two byte encodings can't be swapped by accident, and the round-trip laws can +compare them with `==`. None of the four types hands out what it holds — their +`bytes` and `tree` are copies — so a value cannot change after the compiler made +or checked it, and the way back always works. The optics a caller wants all +start at the script, and are compositions of the stages with `andThen` — a +prism, an iso and a prism make a prism: + +```scala +import dev.constructive.eo.demo.uplc.* + +val toTyped = UplcJvm.toTyped // CborScript ⇀ TypedProgram +val toJvmClass = UplcJvm.toTyped.andThen(UplcJvm.lowering) // CborScript ⇀ JvmClass +val toBytecode = toJvmClass.andThen(UplcJvm.compiling) // CborScript ⇀ JvmClassScript + +val script = CborScript.of(validator.program) // or CborScript.parse(onChainBytes) +val compiled = toBytecode.getOption(script) // the compiler; None: no class file +compiled.map(toBytecode.reverseGet) // Some(script): the class hands its script back +compiled.map(Exec.validate(_, scriptContext)) // Some(Right(traces) | Left(reason)) +``` + +`toJvmClass.getOption(script).map(UplcJvm.compile)` is the same compiler, with +the limit a class exceeds as a `Left`. + +Two properties follow from the shape, and the suite checks both. + +**The laws hold.** `lowering` is a lawful iso on what the compiler produces: +there and back is the identity, both ways. `toTyped` and `toBytecode` are lawful +prisms: `getOption(reverseGet(a)) == Some(a)` for every typed program or class +file `a`, and a script that gets there comes back out. The suite checks both +with cats-eo's own `PrismTests`, and checks the round trips on every program it +compiles, the 943 conformance programs included. + +**The square commutes.** The semantic property is the one a round trip can't +see: *running `toBytecode.getOption(s)` gives what a reference evaluator gives for +`s`*. The demo checks exactly that, against the Scalus CEK machine, for every +program in its test-suite ([Correctness](#correctness-the-cek-machine-as-oracle)). + +## Back and forth + +
+ +The UPLC to JVM round trip +Top row, the optics: a script goes through toTyped to a typed expression, through lowering to its JVM class in memory, and through compiling to a class file; the middle arrow is an iso and the other two prisms, each walked back by reverseGet. Bottom row, the check: the class file is loaded and run, its value is discharged back to a UPLC term, and that term must be alpha-equivalent to the term the Scalus CEK machine computes from the same bytes. + + +eo optics · CborScript ⇀ TypedProgram ≅ JvmClass ⇀ JvmClassScript + + +script +CborScript + +typed expr +TypedProgram + +JVM class +JvmClass + +class file +JvmClassScript + +UPLC term +CEK result + +must agree +α-equal, or both fail + +UPLC term +discharged + +runtime value +closure, constant, … + + + +toTyped + +lowering + +compiling + +load + run + +discharge + + + +Scalus CEK +machine + +forth along the top, back along the bottom + +
+ +The listings in this section are printed, verbatim, by the demo's walkthrough +(give it a directory and it also writes the class file there, for `javap`): + +```sh +sbt "demoUplcJvm/Test/runMain dev.constructive.eo.demo.uplc.Demo [dir-for-the-class-file]" +``` + +### Forth: a script to a typed expression (`toTyped`) + +UPLC has no `let`, no `if` and no multi-argument call; compilers encode them in +lambdas, `delay`/`force` and builtins. `let x = 6 in let y = x * x in x + y` +arrives as: + +``` +(program 1.1.0 [(lam x [(lam y [(builtin addInteger) x y]) [(builtin multiplyInteger) x x]]) (con integer 6)]) +``` + +`toTyped.getOption` checks the script's Plutus Core version, decodes it into +Scalus' own `Term` tree and reads it back as a typed, Scala-like expression; +`toTyped.reverseGet` is the script it was +read from: + +```scala +val v0: BigInt = 6 +val v1: BigInt = multiplyInteger(v0, v0) +addInteger(v0, v1) +``` + +The typer (`Typer.scala`) recognises the encodings UPLC compilers emit and +records them as what they mean: + +- **`let`** — an immediately applied lambda chain, `(λx1 … λxn. body) a1 … an`; +- **`if`** — `force (ifThenElse c (delay a) (delay b))`, and the same idiom for + `chooseList`, `chooseUnit` and `chooseData`; +- **builtin calls** — a builtin applied to exactly its forces and arguments; +- **direct calls** — of `let`-bound functions and of `let`-bound, already forced + builtins; +- **recursion** — `let f = λself … in … [f f] …`, the knot Scalus ties for a + recursive function: when `f` and `self` are only ever applied to themselves, + `self` always holds the function, and its calls are direct calls too; +- **multi-argument calls** — `case (constr k a1 … an) [… f …]`, the shape the + Scalus compiler gives a call with several arguments (one `case` step applies + them all), when `f` is a lambda or a known function; +- **`force (delay t)`** — just `t`. + +Each rewrite is exact under the CEK machine's evaluation order: it only removes +steps nothing can observe (building a closure that is applied at once, delaying a +branch that is forced at once). Anything the typer doesn't recognise stays a +dynamic application and runs exactly as the machine would run it. + +**Hybrid typing.** UPLC is untyped, yet most of a program's scalars are provable +locally — constants, typed builtin results, `let`s of those, branches that +agree. A type is a Scalus `DefaultUni`, and a builtin's signature is Scalus' own +`TypeScheme` for it, instantiated at its arguments' types — `fstPair` of the +`pair integer (list data)` that `unConstrData` returns is an `integer`, so the +`case` that matches a constructor tag on it compiles to a JVM switch. Integers, +booleans, bytestrings and strings get Scala types +(`BigInt`, `Boolean`, `ByteString`, `String`) and an unboxed JVM +representation. Everything else — functions, constructors, `Data`, +whatever flows through a lambda parameter — is a `Value`: a boxed Scalus +`Constant` or a runtime closure. + +On real code — the Fibonacci puzzle validator, written in Scala and compiled to +UPLC by the Scalus plugin — the typed expression makes the program's structure +readable again: + +```scala +val v0: Value = builtin.fstPair.force.force +val v1: Value = builtin.headList.force +val v2: Value = builtin.sndPair.force.force +val v3: Value = builtin.tailList.force +val v4: Value = { + val v4: Value = (v4: Value, v5: Value, v6: Value, v7: Value) => + if lessThanEqualsInteger(v5, 0) then v6 + else v4(v4, subtractInteger(v5, 1), v7, addInteger(v6, v7)) + v4(v4) +} +(v5: Value) => + val v6: Value = sndPair(unConstrData(v5)) + val v7: Value = unConstrData(headList(dropList(2, v6))) + fstPair(v7) match + case 0 => error() + case 1 => if equalsInteger(Constr0(unIData(headList(tailList(v6))), 0, 1) match + case 0 => v4, unIData({ + val v8: Value = unConstrData(headList(tailList(sndPair(v7)))) + fstPair(v8) match + case 0 => headList(sndPair(v8)) + case 1 => error() + })) then () + else error() + case 2 => error() + case 3 => error() + case 4 => error() + case 5 => error() +``` + +The self-recursive helper `v4` is plain `if … then … else v4(v4, …)`, and its +recursive call is a direct JVM call; the `unConstrData` / `sndPair` / +`headList` chains are the script context being decoded, and the `match`es on +`fstPair` are switches on constructor tags. The one call into `v4` goes through +a value the typer cannot see into (`v4(v4)`, a partial application), so it stays +a dynamic `case` — fields first, then the branch — exactly as the machine runs +it. + +### Down: lowering (`lowering`) + +`lowering.get` (`Lower.lower`) writes bytecode straight into ASM's tree +(`ClassNode`, with asm-commons' `InstructionAdapter`) and makes the JVM +decisions on the way: + +- **Closure conversion.** Each lambda chain or `delay` becomes a static method; + a closure captures exactly its free variables, in an order fixed by the + *source* program, so the runtime can read the layout back. +- **Representation.** Typed values stay in unboxed locals and on the operand + stack; boxing happens only where typed code meets dynamic code. +- **Direct calls.** A saturated builtin is a plain call of the function Scalus' + own `CardanoBuiltins` wraps (`scalus.uplc.builtin.Builtins`), on unboxed + operands where its signature allows; calls of known functions are + `invokestatic`s of their body methods. +- **Method size.** Once a method has inlined enough code, the next `let` body + moves to a method of its own (the JVM caps a method at 64 KB of bytecode). +- **The script, embedded.** The static initialiser holds the script as Base64 + string constants; `lowering.reverseGet` reads them back out of the class. + +For the small program, the method `run` is all there is, as ASM prints it; `K` is the class's +table of constants, indexed by UPLC node: + +``` + GETSTATIC dev/constructive/eo/demo/uplc/generated/UplcProgram.K : [Ljava/lang/Object; + BIPUSH 14 + AALOAD + INVOKESTATIC dev/constructive/eo/demo/uplc/runtime/Rt.unInt (Ljava/lang/Object;)Lscala/math/BigInt; + ASTORE 1 + GETSTATIC scalus/uplc/builtin/Builtins$.MODULE$ : Lscalus/uplc/builtin/Builtins$; + ALOAD 1 + ALOAD 1 + INVOKEVIRTUAL scalus/uplc/builtin/AbstractBuiltins.multiplyInteger (Lscala/math/BigInt;Lscala/math/BigInt;)Lscala/math/BigInt; + ASTORE 2 + GETSTATIC scalus/uplc/builtin/Builtins$.MODULE$ : Lscalus/uplc/builtin/Builtins$; + ALOAD 1 + ALOAD 2 + INVOKEVIRTUAL scalus/uplc/builtin/AbstractBuiltins.addInteger (Lscala/math/BigInt;Lscala/math/BigInt;)Lscala/math/BigInt; + INVOKESTATIC dev/constructive/eo/demo/uplc/runtime/Rt.boxInt (Lscala/math/BigInt;)Ljava/lang/Object; + ARETURN +``` + +The constant is unboxed once, the arithmetic is Scalus' own, and the one box is +at the result. + +### To a class file, and back (`compiling`) + +`compiling.getOption` (`UplcJvm.compile`) hands the class's tree to ASM's +`ClassWriter`, which computes the stack map frames and serialises it — unless a +method is over 64 KB or the class over 65 535 constants, when `getOption` is +`None` and `compile` says which; `compiling.reverseGet` (`UplcJvm.decompile`) +is ASM's `ClassReader`. +The class has a static method per lambda chain and `delay`, a switch per call +arity for closure dispatch, and the script, re-decoded by the static initialiser. +A class file survives being read and written again byte for byte because the +generated code has no unreachable instructions — a function that can only fail +is never applied, and a call whose argument can only fail after nothing but +values is that failure — so ASM has no dead code to blank out: + +``` +compiling.getOption: 1844 bytes of class file +and back — toBytecode.reverseGet(that) == script: true +``` + +### And back again: values to UPLC terms + +A UPLC program can evaluate to a closure, and to compare such a result with the +CEK machine's it must become a term again. The compiler numbers every UPLC node +in pre-order; a runtime closure carries only the number of its source node, plus +the values of its free variables. The class re-decodes the program it embeds, +so the runtime can *discharge* a closure — rebuild its source node with every +captured variable replaced by its own discharged value — exactly as the CEK +machine discharges its results: + +``` +(program 1.1.0 [(lam x (lam y x)) (con integer 5)]) + +run + discharge: (lam i0 (con integer 5)) +CEK machine: (lam i0 (con integer 5)) +α-equal: true +``` + +## Correctness: the CEK machine as oracle + +The demo pins one semantics (`Semantics.scala`): Plutus V3 at protocol version +11, builtin semantics variant E — the configuration Scalus 1.3.0 runs the Plutus +conformance suite under. Builtins without a direct implementation, and builtins +used as values, run Scalus' own CEK meanings (`BuiltinRuntime`); a meaning that +hands back one of its arguments (`ifThenElse`, `chooseList`, …) hands back the +closure or constructor it was given. + +`sbt demoUplcJvm/test` checks the commuting square — and, on every program it +compiles, the round trips: the script comes back out of its class, and the class +file survives ASM reading and writing it again — on: + +| suite | what | result | +|---|---|---| +| Plutus conformance | the [`plutus-conformance`](https://github.com/IntersectMBO/plutus/tree/1.63.0.0/plutus-conformance) UPLC evaluation cases, plutus `1.63.0.0` (vendored) | **943 / 943** evaluation cases agree; 55 parser-only tests and 1 program with no flat encoding skipped | +| validators | owner + greeting, hash preimage, time lock, 2-of-3 multisig, Fibonacci puzzle, HTLC — accepting *and* rejecting V3 transactions | **20 / 20** scenarios reach the CEK machine's verdict, both compiled once and applied at run time and compiled with the context applied | +| compiler paths | one hand-written program per path, error paths included, a 20 000-deep `let` chain | all agree | +| optic laws | cats-eo-laws' `PrismTests` for `toTyped` and `toBytecode`, over every validator, a program whose value is a closure, a script of an unknown Plutus Core version, and a program too large for a class file | all laws hold | +| stack safety | programs nested 100 000 deep — `force (delay …)`, builtin calls, lambdas — typed, lowered and compiled on a 1 MB stack | no overflow: a class file, or the JVM limit the class exceeds | + +The JVM's own verifier checks every generated class as it is loaded, and each +conformance case's `.expected` file pins whether it should succeed or fail — so +the harness cannot pass by having both evaluators fail everything. Both sides +report in Scalus' types: the generated code fails with a `MachineError`, as the +CEK machine does, and `Exec.run` returns an evaluation `Result`. + +## Benchmarks + +JMH, in +[`demos/uplc-jvm-bench`](https://github.com/Constructive-Programming/eo/tree/main/demos/uplc-jvm-bench). +Both evaluators validate the same accepting transaction (setup checks that both +accept it before anything is timed): + +- **CEK machine** — Scalus' `PlutusVM.evaluateScript` on the script applied to + its context, with no budget accounting (`NoBudgetSpender`). The generated code + meters nothing either; with the restricting budget spender the ledger uses, + the CEK machine would do a little more work per step. +- **generated class** — compiled and loaded once, in setup. Each operation + evaluates the script and applies it to the context. The compiler does no + optimisation ([Limits](#limits)): the same operations run, as JVM code. + +Average time per operation in **µs (lower is better)**, error = 99.9 % +confidence half-width; allocation per operation from `-prof gc` +(`gc.alloc.rate.norm`). Measured on a 4-vCPU Intel Xeon (2.1 GHz) container, +OpenJDK 21.0.12, Scalus 1.3.0, ASM 9.11, the demo built with `-opt +-opt-inline:**,!scala.**`; three forks, 5 × 1 s measurement after 3 × 1 s +warm-up (5 × 2 s for the Fibonacci scaling runs, whose slow operations took +longer to reach steady state). A shared container is not a quiet benchmark +machine: read the ratios, not the absolute values. + +### Validating a transaction + +| validator | CEK machine (µs) | generated class (µs) | speed-up | CEK alloc/op | class alloc/op | +|---|--:|--:|--:|--:|--:| +| `helloOwner` | 4.57 ± 0.14 | 0.29 ± 0.01 | **15.7×** | 13.3 KB | 1.0 KB | +| `preimage` | 6.29 ± 0.35 | 0.55 ± 0.02 | **11.4×** | 17.8 KB | 1.7 KB | +| `timeLock` | 6.42 ± 0.48 | 0.29 ± 0.01 | **22.1×** | 17.7 KB | 0.8 KB | +| `multisig` | 13.3 ± 0.5 | 0.93 ± 0.05 | **14.4×** | 37.4 KB | 2.6 KB | +| `fibonacci` | 31.5 ± 1.3 | 0.48 ± 0.02 | **65.6×** | 76.9 KB | 1.7 KB | +| `htlc` | 8.37 ± 0.49 | 1.02 ± 0.04 | **8.2×** | 23.0 KB | 2.9 KB | + +Most validators spend their time decoding the script context — `unConstrData`, +`headList`, `sndPair` and friends. The CEK machine runs each one as a builtin +meaning over CEK values, and `unConstrData` turns a constructor's whole field +list into constants. The generated class calls the functions those meanings +wrap directly, reads `Data` lazily — only the fields a script touches become +constants — and matches constructor tags with JVM switches: **8–22×** faster, +with 8–22× less allocation. Where the work is the script's own logic, +interpretation is nearly all of the cost: the Fibonacci puzzle (`n = 30`), a +self-recursive function compiled to direct calls on unboxed integers, validates +**~66×** faster. Against the demo's first, raw-ASM version (same harness, an +earlier run), validation is **2.9–7.1×** faster. + +Rejecting a transaction costs about what accepting one does (0.5–1.6 µs for the +rejecting transactions in the test-suite). A failure leaves the generated code +as a `MachineError` thrown without a stack trace — capturing one cost ~1.3 µs, +more than validating — and `Exec.run` turns it into Scalus' `Result.Failure`. +Returning a result value from every call instead would need a check after each +one: measured, that leaves validation as fast and makes translation 20–35% +slower. + +### Scaling with the work: the Fibonacci puzzle + +| `n` | CEK machine (µs) | generated class (µs) | speed-up | CEK alloc/op | class alloc/op | +|--:|--:|--:|--:|--:|--:| +| 10 | 11.9 ± 0.6 | 0.25 ± 0.01 | **47.7×** | 31.8 KB | 0.9 KB | +| 100 | 92.7 ± 3.0 | 1.87 ± 0.09 | **49.6×** | 235.1 KB | 5.8 KB | +| 1000 | 923.3 ± 78.6 | 42.3 ± 1.4 | **21.8×** | 2,356.0 KB | 143.9 KB | + +The generated code does almost nothing but arithmetic, so the speed-up stays +near 50× until the integers grow: at `n = 1000` they reach ~700 bits, `BigInt` +addition — identical in both evaluators — is most of the time, and the speed-up +settles at ~22×. + +### What translation costs + +| validator | script | class file | translate (µs) | translate + load (µs) | break-even (validations) | +|---|--:|--:|--:|--:|--:| +| `helloOwner` | 149 B | 4,560 B | 95.8 ± 7.6 | 487.6 ± 125.5 | 114 | +| `preimage` | 186 B | 5,026 B | 130.1 ± 18.0 | 592.6 ± 90.2 | 103 | +| `timeLock` | 183 B | 5,100 B | 126.7 ± 12.8 | 517.9 ± 71.6 | 84 | +| `multisig` | 202 B | 6,233 B | 175.1 ± 15.9 | 678.9 ± 80.5 | 55 | +| `fibonacci` | 126 B | 4,342 B | 81.6 ± 7.7 | 387.9 ± 57.5 | 13 | +| `htlc` | 310 B | 6,665 B | 221.9 ± 22.3 | 792.9 ± 166.2 | 108 | + +Translation was measured again once compiling became stack safe ([Limits](#limits)), in a later +session on the same kind of container; there, the version before measured 80–186 µs, so stack +safety costs 13–19% of `translate`. `translate` is `toBytecode.getOption`, measured warm; `translate + load` adds defining +the class, verifying it, and running its static initialiser, which re-decodes the +embedded script. Loading is three quarters of +the total. Most of `translate` is ASM's `ClassWriter` computing stack map frames; +lowering straight into ASM's tree keeps the rest small, and translation costs +about 15% more than the demo's first, raw-ASM emitter did — the price of stack +safety — and about 40% of what a version built on a higher-level bytecode +library (Cojen Maker) cost. +Decoding the script is a few microseconds of it: the numbering is a pure fold +over Scalus' `Term` tree, 2–3× slower than writing into arrays, and paid once +per class. The break-even column divides `translate + load` by the time each +validation saves in the first table: a script must be validated **~13–115 times** before compiling +it pays for itself. That +fits scripts that run over and over — a node re-validating the same reference +scripts, an emulator, a test-suite — rather than one-off evaluation. + +Reproduce with `sbt "demoUplcJvmBench/Jmh/run -prof gc"`. + +## Limits + +- **No optimisation.** The compiler translates UPLC; it does not optimise it. + There is no constant folding, inlining, dead-code elimination, + common-subexpression elimination, specialisation or tail-call elimination: + every operation the program performs still happens at run time, in the order + the CEK machine performs it. (The demo's own Scala code is another matter: it + is built with Scala 3's bytecode optimizer, `-opt`, inlining from everything + but the Scala library.) What the typer recognises — `let`, `if`, known calls — are + encodings it reads back, not changes to the program. The speed-ups above come + from the translation alone: JVM bytecode under the JIT, with values unboxed + and calls made directly where the types allow. +- **No budget metering.** Results and failures are compared, execution budgets + are not, so an out-of-budget script — which the ledger rejects — is accepted + here. Metering the same machine-step costs the CEK machine charges is the + natural next step. +- **The JVM stack.** Compiling cannot overflow it, however deep the program: + decoding, typing and lowering make plain calls while they are shallow, and + from 128 calls deep they continue on the heap, through `cats.Eval` + (trampolining every node instead made translation twice as slow). Scalus' flat decoder + and encoder, which reading and writing a script go through, do recurse: on a + 1 MB stack they overflow between 2 000 and 20 000 levels deep, depending on + how warm the JIT is. Generated code recurses on the JVM stack where the CEK + machine uses the heap; `Exec` runs evaluations on a thread with a 512 MB stack. +- **Method splitting** happens at `let` boundaries only — the shape compilers + produce — not inside one huge expression. A class that still exceeds a JVM + limit has no class file: that is why `compiling` is a prism. + +Scalus has its own experimental JIT (`scalus-uplc-jit-compiler`, built on Scala 3 +staging). This demo is independent of it; its point is the shape — one optic +from bytes to bytes, a typed middle you can read — and a differential harness +that keeps it honest. + +## Running it + +```sh +# the differential suite +sbt demoUplcJvm/test +# the walkthrough above +sbt "demoUplcJvm/Test/runMain dev.constructive.eo.demo.uplc.Demo" +# the benchmarks +sbt "demoUplcJvmBench/Jmh/run -prof gc" +# re-vendor the conformance suite +demos/uplc-jvm/scripts/refresh-conformance.sh [plutus-tag] +``` + +The demo and its benchmarks sit outside the root aggregate (Scalus brings JNI +crypto bindings with it); CI runs the differential suite as its own step. diff --git a/site/docs/directory.conf b/site/docs/directory.conf index 525c829d..457cccb9 100644 --- a/site/docs/directory.conf +++ b/site/docs/directory.conf @@ -11,6 +11,7 @@ laika.navigationOrder = [ integrations extensibility.md cookbook.md + demos benchmarks.md quality-assurance.md migration-from-monocle.md