From 964dc60fc05b586c94d6dc2ac993120fd31dfc10 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Fri, 18 Jul 2025 17:34:12 +0400 Subject: [PATCH 1/2] any op --- src/generated/Rainterpreter.pointers.sol | 4 ++-- ...interpreterExpressionDeployer.pointers.sol | 6 +++--- .../RainterpreterParser.pointers.sol | 8 ++++---- src/lib/op/LibAllStandardOps.sol | 14 +++++++------- .../op/logic/{LibOpAnyNP.sol => LibOpAny.sol} | 19 ++++++++++--------- 5 files changed, 26 insertions(+), 25 deletions(-) rename src/lib/op/logic/{LibOpAnyNP.sol => LibOpAny.sol} (79%) diff --git a/src/generated/Rainterpreter.pointers.sol b/src/generated/Rainterpreter.pointers.sol index 6fb9bb938..fe340c60e 100644 --- a/src/generated/Rainterpreter.pointers.sol +++ b/src/generated/Rainterpreter.pointers.sol @@ -10,11 +10,11 @@ pragma solidity =0.8.25; /// @dev Hash of the known bytecode. -bytes32 constant BYTECODE_HASH = bytes32(0x65839bbc78993c95140ed4476132110d45c4ed446553985be09d23f9af769599); +bytes32 constant BYTECODE_HASH = bytes32(0x1a3fbd5bbbf67323604d9d6e171b5922ce1c661c9f890518b6d8c7c948349acb); /// @dev The function pointers known to the interpreter for dynamic dispatch. /// By setting these as a constant they can be inlined into the interpreter /// and loaded at eval time for very low gas (~100) due to the compiler /// optimising it to a single `codecopy` to build the in memory bytes array. bytes constant OPCODE_FUNCTION_POINTERS = - hex"07a207d407f809840a4d0a5f0a710a8a0aae0ae20af30b040ba60bc50c830d330db70ef9102c0c83112511d7127912f1130213131313132413b113ca13de13f71422143b144e14b014fe154c159a15e81636168416d217031751179f17ed18d4"; + hex"07ab07dd0801098d0a560a680a7a0a930ab70aeb0afc0b0d0baf0bce0c8c0d3c0dc00f0210350c8c112e11e0128212fa130b131c131c132d137413f6140f1423143c14671480149314f51543159115df162d167b16c917171748179617e418321919"; diff --git a/src/generated/RainterpreterExpressionDeployer.pointers.sol b/src/generated/RainterpreterExpressionDeployer.pointers.sol index 848e6fcf5..b8c645a8c 100644 --- a/src/generated/RainterpreterExpressionDeployer.pointers.sol +++ b/src/generated/RainterpreterExpressionDeployer.pointers.sol @@ -10,11 +10,11 @@ pragma solidity =0.8.25; /// @dev Hash of the known bytecode. -bytes32 constant BYTECODE_HASH = bytes32(0x176dcc1d53f1a9b3bc350f2863646819c36b13ceab17bb08d832559a8d6d3c6f); +bytes32 constant BYTECODE_HASH = bytes32(0xd09b4991a12ba8c2a22269ff879e110f22450dba8c3850ebdfd90d37a76936a9); /// @dev The hash of the meta that describes the contract. -bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0xd7a4a73b117bac0f3429a826af5265bf345909808bbbaa7afba58a515344f584); +bytes32 constant DESCRIBED_BY_META_HASH = bytes32(0x7145a744b38f6a8a05a5a427fd2200e8c6e21c50eb3fd5642d251ecac809f67e); /// @dev The function pointers for the integrity check fns. bytes constant INTEGRITY_FUNCTION_POINTERS = - hex"0e380eb60f1a1094109e109e10a810b110cc1172117211ce12461253109e10a81253109e10a8109e109e109e10a81094109410941094125d109e109e109e10a8109e1094126712671267126712671267128f126710941267128f128f10a8125d"; + hex"0e400ebe0f22109c10a610a610b010b910d4117a117a11d6124e125b10a610b0125b10a610b010a610a610a610b0109c109c109c109c1265128a10a610a610a610b010a6109c12941294129412941294129412ae1294109c129412ae12ae10b0128a"; diff --git a/src/generated/RainterpreterParser.pointers.sol b/src/generated/RainterpreterParser.pointers.sol index 31719f815..864fb65a0 100644 --- a/src/generated/RainterpreterParser.pointers.sol +++ b/src/generated/RainterpreterParser.pointers.sol @@ -10,7 +10,7 @@ pragma solidity =0.8.25; /// @dev Hash of the known bytecode. -bytes32 constant BYTECODE_HASH = bytes32(0x4dae17e8ff2c40976367ed98a4f9aca0cc65ea9518e3e922961b3060c694da1d); +bytes32 constant BYTECODE_HASH = bytes32(0x2e38cc130243a36a0482c2e7e70b5928cedb02e1ad0972b7bd7b232b936b7eae); /// @dev The parse meta that is used to lookup word definitions. /// The structure of the parse meta is: @@ -29,7 +29,7 @@ bytes32 constant BYTECODE_HASH = bytes32(0x4dae17e8ff2c40976367ed98a4f9aca0cc65e /// bit count of the previous bloom filter. If we reach the end of the bloom /// filters then we have a miss. bytes constant PARSE_META = - hex"0178a8806000299010810908a00a34484001280030060100180000200cc2200408a00c95d8382e48145c2f34b3f32ad587e204afc8f01d95a26007b9a51f0d5e6f2803ce312215fae0a1241233de118cfd53051c784d22a55ade1681ac9620ac6dfc2ba4e5e91e5fc32a0e92b2401cbbd837100ef76b00cd8814279714ec13313592260d473b1ff880501427634f0f23b4970ac0e53d0b895f991ac908be0983724f12c080bc2c9d7b7d25757aea236f62e0285c0ab5086d2a7b19bcb24402af7d4506414b8117b04fb31bb2182f18ef532921c301e32dfa5d8001336a5929ab2461"; + hex"0178ac806000299010810908a00a34484001280030060100180000200cc2200408a00c95d8382f48145c3034b3f32bd587e204afc8f01e95a26007b9a51f0d5e6f2803ce312215fae0a1251233de118cfd53051c784d23a55ade1681ac9621ac6dfc2ca4e5e91f5fc32a0e92b2401dbbd837100ef76b00cd8814289714ec13313592270d473b20f880501427634f0f23b4970ac0e53d0b895f991ac908be0983724f12c080bc2d9d7b7d26757aea246f62e0295c0ab5086d2a7b19bcb24402af7d4506414b8117b04fb31cb2182f18ef532922c301e31b9314ad2efa5d8001336a592aab2461"; /// @dev The build depth of the parser meta. @@ -39,11 +39,11 @@ uint8 constant PARSE_META_BUILD_DEPTH = 2; /// These positional indexes all map to the same indexes looked up in the parse /// meta. bytes constant OPERAND_HANDLER_FUNCTION_POINTERS = - hex"1a1b1a1b1a1b1af01c071c071c071af01af01a1b1a1b1a1b1c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071c071a1b1c071c07"; + hex"1a231a231a231af81c0f1c0f1c0f1af81af81a231a231a231c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1c0f1a231c0f1c0f"; /// @dev Every two bytes is a function pointer for a literal parser. /// Literal dispatches are determined by the first byte(s) of the literal /// rather than a full word lookup, and are done with simple conditional /// jumps as the possibilities are limited compared to the number of words we /// have. -bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"1563179517d81876"; +bytes constant LITERAL_PARSER_FUNCTION_POINTERS = hex"156b179d17e0187e"; diff --git a/src/lib/op/LibAllStandardOps.sol b/src/lib/op/LibAllStandardOps.sol index 470704c68..ea4c48e42 100644 --- a/src/lib/op/LibAllStandardOps.sol +++ b/src/lib/op/LibAllStandardOps.sol @@ -46,7 +46,7 @@ import {LibOpBlockNumber} from "./evm/LibOpBlockNumber.sol"; import {LibOpChainId} from "./evm/LibOpChainId.sol"; import {LibOpTimestamp} from "./evm/LibOpTimestamp.sol"; -import {LibOpAnyNP} from "./logic/LibOpAnyNP.sol"; +import {LibOpAny} from "./logic/LibOpAny.sol"; import {LibOpConditionsNP} from "./logic/LibOpConditionsNP.sol"; import {LibOpEnsure} from "./logic/LibOpEnsure.sol"; import {LibOpEqualTo} from "./logic/LibOpEqualTo.sol"; @@ -108,7 +108,7 @@ import {LibParseLiteralHex} from "../parse/literal/LibParseLiteralHex.sol"; import {LibParseLiteralSubParseable} from "../parse/literal/LibParseLiteralSubParseable.sol"; /// @dev Number of ops currently provided by `AllStandardOps`. -uint256 constant ALL_STANDARD_OPS_LENGTH = 48; +uint256 constant ALL_STANDARD_OPS_LENGTH = 49; /// @title LibAllStandardOps /// @notice Every opcode available from the core repository laid out as a single @@ -206,7 +206,7 @@ library LibAllStandardOps { AuthoringMetaV2("chain-id", "The current chain id."), AuthoringMetaV2("block-timestamp", "The current block timestamp."), AuthoringMetaV2("now", "The current block timestamp."), - // AuthoringMetaV2("any", "The first non-zero value out of all inputs, or 0 if every input is 0."), + AuthoringMetaV2("any", "The first binary non-zero value out of all inputs, or 0 if every input is 0."), // AuthoringMetaV2( // "conditions", // "Treats inputs as pairwise condition/value pairs. The first nonzero condition's value is used. If no conditions are nonzero, the expression reverts. Provide a constant nonzero value to define a fallback case. If the number of inputs is odd, the final value is used as an error string in the case that no conditions match." @@ -430,8 +430,8 @@ library LibAllStandardOps { LibParseOperand.handleOperandDisallowed, // now LibParseOperand.handleOperandDisallowed, - // // any - // LibParseOperand.handleOperandDisallowed, + // any + LibParseOperand.handleOperandDisallowed, // // conditions // LibParseOperand.handleOperandDisallowed, // ensure @@ -592,7 +592,7 @@ library LibAllStandardOps { LibOpTimestamp.integrity, // now LibOpTimestamp.integrity, - // LibOpAnyNP.integrity, + LibOpAny.integrity, // LibOpConditionsNP.integrity, LibOpEnsure.integrity, LibOpEqualTo.integrity, @@ -707,7 +707,7 @@ library LibAllStandardOps { LibOpTimestamp.run, // now LibOpTimestamp.run, - // LibOpAnyNP.run, + LibOpAny.run, // LibOpConditionsNP.run, LibOpEnsure.run, LibOpEqualTo.run, diff --git a/src/lib/op/logic/LibOpAnyNP.sol b/src/lib/op/logic/LibOpAny.sol similarity index 79% rename from src/lib/op/logic/LibOpAnyNP.sol rename to src/lib/op/logic/LibOpAny.sol index 9bd132a69..5a0b847f4 100644 --- a/src/lib/op/logic/LibOpAnyNP.sol +++ b/src/lib/op/logic/LibOpAny.sol @@ -5,11 +5,12 @@ import {OperandV2} from "rain.interpreter.interface/interface/unstable/IInterpre import {Pointer} from "rain.solmem/lib/LibPointer.sol"; import {IntegrityCheckState} from "../../integrity/LibIntegrityCheck.sol"; import {InterpreterState} from "../../state/LibInterpreterState.sol"; +import {StackItem} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; -/// @title LibOpAnyNP +/// @title LibOpAny /// @notice Opcode to return the first nonzero item on the stack up to the inputs /// limit. -library LibOpAnyNP { +library LibOpAny { function integrity(IntegrityCheckState memory, OperandV2 operand) internal pure returns (uint256, uint256) { // There must be at least one input. uint256 inputs = uint256((OperandV2.unwrap(operand) >> 0x10) & bytes32(uint256(0x0F))); @@ -36,21 +37,21 @@ library LibOpAnyNP { } /// Gas intensive reference implementation of ANY for testing. - function referenceFn(InterpreterState memory, OperandV2, uint256[] memory inputs) + function referenceFn(InterpreterState memory, OperandV2, StackItem[] memory inputs) internal pure - returns (uint256[] memory outputs) + returns (StackItem[] memory outputs) { // Zero length inputs is not supported so this 0 will always be written // over. - uint256 value = 0; + bytes32 value = 0; for (uint256 i = 0; i < inputs.length; i++) { - value = inputs[i]; - if (value != 0) { + value = StackItem.unwrap(inputs[i]); + if (value != bytes32(0)) { break; } } - outputs = new uint256[](1); - outputs[0] = value; + outputs = new StackItem[](1); + outputs[0] = StackItem.wrap(value); } } From d9e9788ad341bc56ec7ceb5caa672ba8601a0979 Mon Sep 17 00:00:00 2001 From: thedavidmeister Date: Fri, 18 Jul 2025 17:47:18 +0400 Subject: [PATCH 2/2] any op tests --- test/src/lib/op/logic/LibOpAny.t.sol | 147 +++++++++++++++++++++++++ test/src/lib/op/logic/LibOpAnyNP.t.sol | 141 ------------------------ 2 files changed, 147 insertions(+), 141 deletions(-) create mode 100644 test/src/lib/op/logic/LibOpAny.t.sol delete mode 100644 test/src/lib/op/logic/LibOpAnyNP.t.sol diff --git a/test/src/lib/op/logic/LibOpAny.t.sol b/test/src/lib/op/logic/LibOpAny.t.sol new file mode 100644 index 000000000..40483df58 --- /dev/null +++ b/test/src/lib/op/logic/LibOpAny.t.sol @@ -0,0 +1,147 @@ +// SPDX-License-Identifier: CAL +pragma solidity =0.8.25; + +import {Pointer} from "rain.solmem/lib/LibPointer.sol"; +import {LibUint256Array} from "rain.solmem/lib/LibUint256Array.sol"; +import {MemoryKV} from "rain.lib.memkv/lib/LibMemoryKV.sol"; + +import {OpTest} from "test/abstract/OpTest.sol"; +import {LibOpAny} from "src/lib/op/logic/LibOpAny.sol"; +import { + IInterpreterV4, OperandV2, SourceIndexV2 +} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; +import { + IInterpreterStoreV3, + FullyQualifiedNamespace +} from "rain.interpreter.interface/interface/unstable/IInterpreterStoreV3.sol"; +import {LibIntegrityCheck, IntegrityCheckState} from "src/lib/integrity/LibIntegrityCheck.sol"; +import {LibInterpreterState, InterpreterState} from "src/lib/state/LibInterpreterState.sol"; +import {BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol"; +import {LibOperand} from "test/lib/operand/LibOperand.sol"; +import {StackItem} from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; + +contract LibOpAnyTest is OpTest { + using LibUint256Array for uint256[]; + + /// Directly test the integrity logic of LibOpAny. This tests the happy + /// path where the operand is valid. + function testOpAnyIntegrityHappy(uint8 inputs, uint16 operandData) external pure { + IntegrityCheckState memory state = opTestDefaultIngegrityCheckState(); + inputs = uint8(bound(uint256(inputs), 1, 0x0F)); + (uint256 calcInputs, uint256 calcOutputs) = LibOpAny.integrity(state, LibOperand.build(inputs, 1, operandData)); + + assertEq(calcInputs, inputs); + assertEq(calcOutputs, 1); + } + + /// Sample the gas cost of the integrity check. + function testOpAnyIntegrityGas0() external { + vm.pauseGasMetering(); + IntegrityCheckState memory state = IntegrityCheckState(6, 6, 6, new bytes32[](3), 9, ""); + OperandV2 operand = OperandV2.wrap(bytes32(uint256(0x50000))); + vm.resumeGasMetering(); + // 5 inputs. Any stack index above this is fine for the state. + (uint256 calcInputs, uint256 calcOutputs) = LibOpAny.integrity(state, operand); + (calcInputs); + (calcOutputs); + } + + /// Directly test the integrity logic of LibOpAny. This tests the unhappy + /// path where the operand is invalid due to 0 inputs. + function testOpAnyIntegrityUnhappyZeroInputs() external pure { + IntegrityCheckState memory state = opTestDefaultIngegrityCheckState(); + (uint256 calcInputs, uint256 calcOutputs) = LibOpAny.integrity(state, OperandV2.wrap(0)); + // Calc inputs will be minimum 1. + assertEq(calcInputs, 1); + assertEq(calcOutputs, 1); + } + + function _testOpAnyRun(OperandV2 operand, StackItem[] memory inputs) external view { + InterpreterState memory state = opTestDefaultInterpreterState(); + opReferenceCheck(state, operand, LibOpAny.referenceFn, LibOpAny.integrity, LibOpAny.run, inputs); + } + + /// Directly test the runtime logic of LibOpAny. + function testOpAnyRun(StackItem[] memory inputs, uint16 operandData) external view { + vm.assume(inputs.length != 0); + vm.assume(inputs.length <= 0x0F); + OperandV2 operand = LibOperand.build(uint8(inputs.length), 1, operandData); + this._testOpAnyRun(operand, inputs); + } + + /// Sample the gas cost of the run function. + function testOpAnyRunGas0() external { + vm.pauseGasMetering(); + StackItem[][] memory stacks = new StackItem[][](1); + stacks[0] = new StackItem[](1); + Pointer stackTop; + assembly ("memory-safe") { + stackTop := add(stacks, 0x20) + } + InterpreterState memory state = InterpreterState( + LibInterpreterState.stackBottoms(stacks), + new bytes32[](0), + 0, + MemoryKV.wrap(0), + FullyQualifiedNamespace.wrap(0), + IInterpreterStoreV3(address(0)), + new bytes32[][](0), + "", + "" + ); + OperandV2 operand = OperandV2.wrap(bytes32(uint256(0x10000))); + vm.resumeGasMetering(); + // 1 inputs. Any stack index above this is fine for the state. + LibOpAny.run(state, operand, stackTop); + } + + /// Test the eval of any opcode parsed from a string. Tests 1 true input. + function testOpAnyEval1TrueInput() external view { + checkHappy("_: any(5);", bytes32(uint256(5)), ""); + } + + /// Test the eval of any opcode parsed from a string. Tests 1 false input. + function testOpAnyEval1FalseInput() external view { + checkHappy("_: any(0);", 0, ""); + } + + /// Test the eval of any opcode parsed from a string. Tests 2 true inputs. + /// The first true input should be the overall result. + function testOpAnyEval2TrueInputs() external view { + checkHappy("_: any(5 6);", bytes32(uint256(5)), ""); + } + + /// Test the eval of any opcode parsed from a string. Tests 2 false inputs. + function testOpAnyEval2FalseInputs() external view { + checkHappy("_: any(0 0);", 0, ""); + } + + /// Test the eval of any opcode parsed from a string. Tests 2 inputs, one + /// true and one false. The first true input should be the overall result. + /// The first value is the true value. + function testOpAnyEval2MixedInputs() external view { + checkHappy("_: any(5 0);", bytes32(uint256(5)), ""); + } + + /// Test the eval of any opcode parsed from a string. Tests 2 inputs, one + /// true and one false. The first true input should be the overall result. + /// The first value is the false value. + function testOpAnyEval2MixedInputs2() external view { + checkHappy("_: any(0 5);", bytes32(uint256(5)), ""); + } + + /// Test that any without inputs fails integrity check. + function testOpAnyEvalFail() public { + vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 0, 1, 0)); + bytes memory bytecode = iDeployer.parse2("_: any();"); + (bytecode); + } + + function testOpAnyZeroOutputs() external { + checkBadOutputs(": any(0);", 1, 1, 0); + } + + function testOpAnyTwoOutputs() external { + checkBadOutputs("_ _: any(0);", 1, 1, 2); + } +} diff --git a/test/src/lib/op/logic/LibOpAnyNP.t.sol b/test/src/lib/op/logic/LibOpAnyNP.t.sol deleted file mode 100644 index 0d517ed24..000000000 --- a/test/src/lib/op/logic/LibOpAnyNP.t.sol +++ /dev/null @@ -1,141 +0,0 @@ -// SPDX-License-Identifier: CAL -pragma solidity =0.8.25; - -// // import {Pointer} from "rain.solmem/lib/LibPointer.sol"; -// // import {LibUint256Array} from "rain.solmem/lib/LibUint256Array.sol"; -// // import {MemoryKV} from "rain.lib.memkv/lib/LibMemoryKV.sol"; - -// // import {OpTest} from "test/abstract/OpTest.sol"; -// // import {LibContext} from "rain.interpreter.interface/lib/caller/LibContext.sol"; -// // import {LibOpAnyNP} from "src/lib/op/logic/LibOpAnyNP.sol"; -// // import { -// // IInterpreterV4, Operand, SourceIndexV2 -// // } from "rain.interpreter.interface/interface/unstable/IInterpreterV4.sol"; -// // import { -// // IInterpreterStoreV2, FullyQualifiedNamespace -// // } from "rain.interpreter.interface/interface/IInterpreterStoreV2.sol"; -// // import {SignedContextV1} from "rain.interpreter.interface/interface/IInterpreterCallerV3.sol"; -// // import {LibIntegrityCheck, IntegrityCheckState} from "src/lib/integrity/LibIntegrityCheck.sol"; -// // import {LibInterpreterState, InterpreterState} from "src/lib/state/LibInterpreterState.sol"; -// // import {BadOpInputsLength} from "src/lib/integrity/LibIntegrityCheck.sol"; -// // import {LibOperand} from "test/lib/operand/LibOperand.sol"; - -// // contract LibOpAnyNPTest is OpTest { -// // using LibUint256Array for uint256[]; - -// /// Directly test the integrity logic of LibOpAnyNP. This tests the happy -// /// path where the operand is valid. -// function testOpAnyNPIntegrityHappy(uint8 inputs, uint16 operandData) external pure { -// IntegrityCheckState memory state = opTestDefaultIngegrityCheckState(); -// inputs = uint8(bound(uint256(inputs), 1, 0x0F)); -// (uint256 calcInputs, uint256 calcOutputs) = -// LibOpAnyNP.integrity(state, LibOperand.build(inputs, 1, operandData)); - -// // assertEq(calcInputs, inputs); -// // assertEq(calcOutputs, 1); -// // } - -// // /// Sample the gas cost of the integrity check. -// // function testOpAnyNPIntegrityGas0() external { -// // vm.pauseGasMetering(); -// // IntegrityCheckState memory state = IntegrityCheckState(6, 6, 6, new uint256[](3), 9, ""); -// // Operand operand = Operand.wrap(0x50000); -// // vm.resumeGasMetering(); -// // // 5 inputs. Any stack index above this is fine for the state. -// // (uint256 calcInputs, uint256 calcOutputs) = LibOpAnyNP.integrity(state, operand); -// // (calcInputs); -// // (calcOutputs); -// // } - -// /// Directly test the integrity logic of LibOpAnyNP. This tests the unhappy -// /// path where the operand is invalid due to 0 inputs. -// function testOpAnyNPIntegrityUnhappyZeroInputs() external pure { -// IntegrityCheckState memory state = opTestDefaultIngegrityCheckState(); -// (uint256 calcInputs, uint256 calcOutputs) = LibOpAnyNP.integrity(state, Operand.wrap(0)); -// // Calc inputs will be minimum 1. -// assertEq(calcInputs, 1); -// assertEq(calcOutputs, 1); -// } - -// /// Directly test the runtime logic of LibOpAnyNP. -// function testOpAnyNPRun(uint256[] memory inputs, uint16 operandData) external view { -// InterpreterState memory state = opTestDefaultInterpreterState(); -// vm.assume(inputs.length != 0); -// vm.assume(inputs.length <= 0x0F); -// Operand operand = LibOperand.build(uint8(inputs.length), 1, operandData); -// opReferenceCheck(state, operand, LibOpAnyNP.referenceFn, LibOpAnyNP.integrity, LibOpAnyNP.run, inputs); -// } - -// // /// Sample the gas cost of the run function. -// // function testOpAnyNPRunGas0() external { -// // vm.pauseGasMetering(); -// // uint256[][] memory stacks = new uint256[][](1); -// // stacks[0] = new uint256[](1); -// // Pointer stackTop = stacks[0].dataPointer(); -// // InterpreterState memory state = InterpreterState( -// // LibInterpreterState.stackBottoms(stacks), -// // new uint256[](0), -// // 0, -// // MemoryKV.wrap(0), -// // FullyQualifiedNamespace.wrap(0), -// // IInterpreterStoreV2(address(0)), -// // new uint256[][](0), -// // "", -// // "" -// // ); -// // Operand operand = Operand.wrap(0x10000); -// // vm.resumeGasMetering(); -// // // 1 inputs. Any stack index above this is fine for the state. -// // LibOpAnyNP.run(state, operand, stackTop); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 1 true input. -// // function testOpAnyNPEval1TrueInput() external { -// // checkHappy("_: any(5);", 5e18, ""); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 1 false input. -// // function testOpAnyNPEval1FalseInput() external { -// // checkHappy("_: any(0);", 0, ""); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 2 true inputs. -// // /// The first true input should be the overall result. -// // function testOpAnyNPEval2TrueInputs() external { -// // checkHappy("_: any(5 6);", 5e18, ""); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 2 false inputs. -// // function testOpAnyNPEval2FalseInputs() external { -// // checkHappy("_: any(0 0);", 0, ""); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 2 inputs, one -// // /// true and one false. The first true input should be the overall result. -// // /// The first value is the true value. -// // function testOpAnyNPEval2MixedInputs() external { -// // checkHappy("_: any(5 0);", 5e18, ""); -// // } - -// // /// Test the eval of any opcode parsed from a string. Tests 2 inputs, one -// // /// true and one false. The first true input should be the overall result. -// // /// The first value is the false value. -// // function testOpAnyNPEval2MixedInputs2() external { -// // checkHappy("_: any(0 5);", 5e18, ""); -// // } - -// // /// Test that any without inputs fails integrity check. -// // function testOpAnyNPEvalFail() public { -// // vm.expectRevert(abi.encodeWithSelector(BadOpInputsLength.selector, 0, 1, 0)); -// // bytes memory bytecode = iDeployer.parse2("_: any();"); -// // (bytecode); -// // } - -// // function testOpAnyNPZeroOutputs() external { -// // checkBadOutputs(": any(0);", 1, 1, 0); -// // } - -// // function testOpAnyNPTwoOutputs() external { -// // checkBadOutputs("_ _: any(0);", 1, 1, 2); -// // } -// // }