Move RaindexV6 file-level declarations out; compile it via IR at 800 runs

Errors, constants and structs move to src/error, src/constant and src/struct.
Tests reach RaindexV6 and its inheriting harnesses through artifacts and
interfaces so only the restricted profile compiles RaindexV6.sol.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: thedavidmeister

foundry.toml

@@ -34,11 +34,14 @@ evm_version = "cancun"
 
 # optimizer settings for snapshotting.
 optimizer = true
-# Lowered from 1000000 → 1000 → 800 to stay under the EIP-170 24576-byte
-# contract size limit. With the per-owner state overlay removed (untaken orders
-# make no state change), RaindexV6 is 24,424 bytes at 800 runs (152 under).
 optimizer_runs = 800
 
+# RaindexV6 only fits EIP-170 via IR. Changing this profile moves its Zoltu address.
+additional_compiler_profiles = [{ name = "raindex", via_ir = true, optimizer_runs = 800 }]
+compilation_restrictions = [
+  { paths = "src/concrete/raindex/RaindexV6.sol", via_ir = true, min_optimizer_runs = 800, max_optimizer_runs = 800 },
+]
+
 bytecode_hash = "none"
 cbor_metadata = false
 

script/Build.sol

@@ -10,11 +10,7 @@ import {LibFs} from "rain-sol-codegen-0.1.39/src/lib/LibFs.sol";
 import {LibGenParseMeta} from "rainlang-interface-0.2.13/src/lib/codegen/LibGenParseMeta.sol";
 import {DeployCandidate} from "../src/abstract/RainDeploySuitesBase.sol";
 import {RaindexDeploySuites} from "../src/abstract/RaindexDeploySuites.sol";
-import {RaindexV6} from "../src/concrete/raindex/RaindexV6.sol";
 import {RaindexV6SubParser} from "../src/concrete/parser/RaindexV6SubParser.sol";
-import {GenericPoolRaindexV6ArbOrderTaker} from "../src/concrete/arb/GenericPoolRaindexV6ArbOrderTaker.sol";
-import {RouteProcessorRaindexV6ArbOrderTaker} from "../src/concrete/arb/RouteProcessorRaindexV6ArbOrderTaker.sol";
-import {GenericPoolRaindexV6FlashBorrower} from "../src/concrete/arb/GenericPoolRaindexV6FlashBorrower.sol";
 import {ROUTE_PROCESSOR_4_CREATION_CODE} from "../src/lib/deploy/LibRouteProcessor4CreationCode.sol";
 import {LibRaindexSubParser, EXTERN_PARSE_META_BUILD_DEPTH} from "../src/lib/LibRaindexSubParser.sol";
 
@@ -27,9 +23,9 @@ struct GeneratedContract {
     /// The released lib takes its suite key and artifact path from its
     /// `snapshot`.
     DeployCandidate candidate;
-    /// The creation code its snapshot is written from, with
-    /// `candidate.snapshot.dependencies`.
-    bytes sourceCreationCode;
+    /// Creation code for an unanchorable candidate; empty means read the
+    /// `artifactPath` artifact, keeping restricted compiler profiles out of here.
+    bytes pinnedCreationCode;
 }
 
 /// @title Build
@@ -52,32 +48,32 @@ contract Build is BuildScript, RaindexDeploySuites {
     function generatedContracts() internal pure returns (GeneratedContract[] memory) {
         GeneratedContract[] memory contracts = new GeneratedContract[](6);
         contracts[0] = GeneratedContract({
-            contractName: "RaindexV6", candidate: raindexCandidate(), sourceCreationCode: type(RaindexV6).creationCode
+            contractName: "RaindexV6", candidate: raindexCandidate(), pinnedCreationCode: ""
         });
         contracts[1] = GeneratedContract({
             contractName: "RaindexV6SubParser",
             candidate: subParserCandidate(),
-            sourceCreationCode: type(RaindexV6SubParser).creationCode
+            pinnedCreationCode: ""
         });
         contracts[2] = GeneratedContract({
             contractName: "RouteProcessor4",
             candidate: routeProcessorCandidate(),
-            sourceCreationCode: ROUTE_PROCESSOR_4_CREATION_CODE
+            pinnedCreationCode: ROUTE_PROCESSOR_4_CREATION_CODE
         });
         contracts[3] = GeneratedContract({
             contractName: "GenericPoolRaindexV6ArbOrderTaker",
             candidate: genericPoolArbOrderTakerCandidate(),
-            sourceCreationCode: type(GenericPoolRaindexV6ArbOrderTaker).creationCode
+            pinnedCreationCode: ""
         });
         contracts[4] = GeneratedContract({
             contractName: "RouteProcessorRaindexV6ArbOrderTaker",
             candidate: routeProcessorArbOrderTakerCandidate(),
-            sourceCreationCode: type(RouteProcessorRaindexV6ArbOrderTaker).creationCode
+            pinnedCreationCode: ""
         });
         contracts[5] = GeneratedContract({
             contractName: "GenericPoolRaindexV6FlashBorrower",
             candidate: genericPoolFlashBorrowerCandidate(),
-            sourceCreationCode: type(GenericPoolRaindexV6FlashBorrower).creationCode
+            pinnedCreationCode: ""
         });
         return contracts;
     }
@@ -120,7 +116,9 @@ contract Build is BuildScript, RaindexDeploySuites {
                 recordRoot(),
                 LibRainDeploySnapshot.CANDIDATE,
                 contracts[i].contractName,
-                contracts[i].sourceCreationCode,
+                bytes(contracts[i].candidate.unanchorableReason).length == 0
+                    ? vm.getCode(contracts[i].candidate.snapshot.artifactPath)
+                    : contracts[i].pinnedCreationCode,
                 contracts[i].candidate.snapshot.dependencies
             );
         }

src/concrete/raindex/RaindexV6.sol

@@ -65,122 +65,27 @@ import {LibBytes32Array} from "rain-solmem-0.1.28/src/lib/LibBytes32Array.sol";
 import {LibBytes32Matrix} from "rain-solmem-0.1.28/src/lib/LibBytes32Matrix.sol";
 
 import {LibFormatDecimalFloat} from "rain-math-float-0.3.10/src/lib/format/LibFormatDecimalFloat.sol";
-
-/// This will exist in a future version of Open Zeppelin if their main branch is
-/// to be believed.
-error ReentrancyGuardReentrantCall();
-
-/// Thrown when the `msg.sender` modifying an order is not its owner.
-/// @param owner The owner of the order.
-error NotOrderOwner(address owner);
-
-/// Thrown when the input and output tokens don't match, in either direction.
-error TokenMismatch();
-
-/// Thrown when the minimum input is not met.
-/// @param minimumIO The minimum io required.
-/// @param actualIO The io that was achieved.
-error MinimumIO(Float minimumIO, Float actualIO);
-
-/// Thrown when two orders have the same owner during clear.
-error SameOwner();
-
-/// Thrown when calculate order expression offers too few outputs.
-/// @param outputs The outputs the expression offers.
-error UnsupportedCalculateOutputs(uint256 outputs);
-
-/// Thrown when a negative vault balance is being recorded.
-/// @param vaultBalance The negative vault balance being recorded.
-error NegativeVaultBalance(Float vaultBalance);
-
-/// Thrown when a negative amount is being applied to a vault balance.
-/// @param amount The negative amount being applied.
-error NegativeVaultBalanceChange(Float amount);
-
-/// Thrown when a negative pull is attempted.
-error NegativePull();
-
-/// Thrown when a negative push is attempted.
-error NegativePush();
-
-/// Throws when a negative bounty is calculated.
-error NegativeBounty();
-
-/// Thrown when clear output amounts are both zero.
-error ClearZeroAmount();
-
-/// @dev Stored value for a live order. NOT a boolean because storing a boolean
-/// is more expensive than storing a uint256.
-uint256 constant ORDER_LIVE = 1;
-
-/// @dev Stored value for a dead order. `0` is chosen because it is the default
-/// value for a mapping, which means all orders are dead unless explicitly made
-/// live.
-uint256 constant ORDER_DEAD = 0;
-
-/// @dev Entrypoint to a calculate the amount and ratio of an order.
-SourceIndexV2 constant CALCULATE_ORDER_ENTRYPOINT = SourceIndexV2.wrap(0);
-/// @dev Entrypoint to handle the final internal vault movements resulting from
-/// matching multiple calculated orders.
-SourceIndexV2 constant HANDLE_IO_ENTRYPOINT = SourceIndexV2.wrap(1);
-
-/// @dev Minimum outputs for calculate order are the amount and ratio.
-uint256 constant CALCULATE_ORDER_MIN_OUTPUTS = 2;
-/// @dev Maximum outputs for calculate order are the amount and ratio.
-uint16 constant CALCULATE_ORDER_MAX_OUTPUTS = 2;
-
-/// @dev Handle IO has no outputs as it only responds to vault movements.
-uint256 constant HANDLE_IO_MIN_OUTPUTS = 0;
-/// @dev Handle IO has no outputs as it only responds to vault movements.
-uint16 constant HANDLE_IO_MAX_OUTPUTS = 0;
-
-/// All information resulting from an order calculation that allows for vault IO
-/// to be calculated and applied, then the handle IO entrypoint to be dispatched.
-/// @param outputMax The maximum output calculated by the order expression as a
-/// Float. WILL BE RESCALED ACCORDING TO TOKEN DECIMALS (read via TOFU) for the
-/// purpose of calculating actual vault movements.
-/// The output max is CAPPED AT THE OUTPUT VAULT BALANCE OF THE ORDER OWNER.
-/// The order is guaranteed that the total output of this single clearance cannot
-/// exceed this (subject to rescaling). It is up to the order expression to track
-/// values over time if the output max is to impose a global limit across many
-/// transactions and counterparties.
-/// @param IORatio The order ratio as input/output from the perspective of the
-/// order, as a Float. As each counterparty's input is the other's output, the
-/// IORatio calculated by each order is inverse of its counterparty. IORatio is
-/// RESCALED ACCORDING TO TOKEN DECIMALS (read via TOFU) when applied to vault
-/// balances. I.e. a ratio of `1` is ALWAYS "one" as ECONOMIC EQUIVALENCE
-/// between two tokens, but this will be rescaled according to the decimals of
-/// the token. For example, if DAI and USDT have a ratio of `1` then in reality
-/// `1e12` DAI will move in the vault for every `1` USDT that moves, because DAI
-/// has `1e18` decimals per $1 peg and USDT has `1e6` decimals per $1 peg.
-/// @param context The entire 2D context array, initialized from the context
-/// passed into the order calculations and then populated with the order
-/// calculations and vault IO before being passed back to handle IO entrypoint.
-/// @param namespace The `StateNamespace` to be passed to the store for calculate
-/// IO state changes.
-/// @param kvs KVs returned from calculate order entrypoint to pass to the store
-/// before calling handle IO entrypoint.
-struct OrderIOCalculationV4 {
-    OrderV4 order;
-    uint256 outputIOIndex;
-    Float outputMax;
-    //solhint-disable-next-line var-name-mixedcase
-    Float IORatio;
-    bytes32[][] context;
-    StateNamespace namespace;
-    bytes32[] kvs;
-}
-
-/// The input and output tokens shared by every order in a `takeOrders4` batch,
-/// and the taker IO still remaining to fill as the batch is processed.
-/// @param inputToken The input token every order in the batch must use.
-/// @param outputToken The output token every order in the batch must use.
-/// @param remainingTakerIO The taker IO left to fill across the batch.
-struct TakeOrdersIO {
-    address inputToken;
-    address outputToken;
-    Float remainingTakerIO;
-}
+import {
+    NotOrderOwner,
+    TokenMismatch,
+    MinimumIO,
+    SameOwner,
+    UnsupportedCalculateOutputs,
+    NegativeVaultBalance,
+    NegativeVaultBalanceChange,
+    NegativePull,
+    NegativePush,
+    NegativeBounty,
+    ClearZeroAmount
+} from "../../error/ErrRaindexV6.sol";
+import {ORDER_LIVE, ORDER_DEAD} from "../../constant/OrderLiveness.sol";
+import {
+    CALCULATE_ORDER_ENTRYPOINT,
+    HANDLE_IO_ENTRYPOINT,
+    CALCULATE_ORDER_MIN_OUTPUTS
+} from "../../constant/OrderEntrypoints.sol";
+import {OrderIOCalculationV4} from "../../struct/OrderIOCalculationV4.sol";
+import {TakeOrdersIO} from "../../struct/TakeOrdersIO.sol";
 
 /// @title RaindexV6
 /// See `IRaindexV6` for more documentation.

src/constant/OrderEntrypoints.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+import {SourceIndexV2} from "rainlang-interface-0.2.13/src/interface/IInterpreterV4.sol";
+
+/// @dev Entrypoint to a calculate the amount and ratio of an order.
+SourceIndexV2 constant CALCULATE_ORDER_ENTRYPOINT = SourceIndexV2.wrap(0);
+/// @dev Entrypoint to handle the final internal vault movements resulting from
+/// matching multiple calculated orders.
+SourceIndexV2 constant HANDLE_IO_ENTRYPOINT = SourceIndexV2.wrap(1);
+
+/// @dev Minimum outputs for calculate order are the amount and ratio.
+uint256 constant CALCULATE_ORDER_MIN_OUTPUTS = 2;
+/// @dev Maximum outputs for calculate order are the amount and ratio.
+uint16 constant CALCULATE_ORDER_MAX_OUTPUTS = 2;
+
+/// @dev Handle IO has no outputs as it only responds to vault movements.
+uint256 constant HANDLE_IO_MIN_OUTPUTS = 0;
+/// @dev Handle IO has no outputs as it only responds to vault movements.
+uint16 constant HANDLE_IO_MAX_OUTPUTS = 0;

src/constant/OrderLiveness.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+/// @dev Stored value for a live order. NOT a boolean because storing a boolean
+/// is more expensive than storing a uint256.
+uint256 constant ORDER_LIVE = 1;
+
+/// @dev Stored value for a dead order. `0` is chosen because it is the default
+/// value for a mapping, which means all orders are dead unless explicitly made
+/// live.
+uint256 constant ORDER_DEAD = 0;

src/error/ErrRaindexV6.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+import {Float} from "rain-math-float-0.3.10/src/lib/LibDecimalFloat.sol";
+
+/// This will exist in a future version of Open Zeppelin if their main branch is
+/// to be believed.
+error ReentrancyGuardReentrantCall();
+
+/// Thrown when the `msg.sender` modifying an order is not its owner.
+/// @param owner The owner of the order.
+error NotOrderOwner(address owner);
+
+/// Thrown when the input and output tokens don't match, in either direction.
+error TokenMismatch();
+
+/// Thrown when the minimum input is not met.
+/// @param minimumIO The minimum io required.
+/// @param actualIO The io that was achieved.
+error MinimumIO(Float minimumIO, Float actualIO);
+
+/// Thrown when two orders have the same owner during clear.
+error SameOwner();
+
+/// Thrown when calculate order expression offers too few outputs.
+/// @param outputs The outputs the expression offers.
+error UnsupportedCalculateOutputs(uint256 outputs);
+
+/// Thrown when a negative vault balance is being recorded.
+/// @param vaultBalance The negative vault balance being recorded.
+error NegativeVaultBalance(Float vaultBalance);
+
+/// Thrown when a negative amount is being applied to a vault balance.
+/// @param amount The negative amount being applied.
+error NegativeVaultBalanceChange(Float amount);
+
+/// Thrown when a negative pull is attempted.
+error NegativePull();
+
+/// Thrown when a negative push is attempted.
+error NegativePush();
+
+/// Throws when a negative bounty is calculated.
+error NegativeBounty();
+
+/// Thrown when clear output amounts are both zero.
+error ClearZeroAmount();

src/struct/OrderIOCalculationV4.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+import {OrderV4, Float} from "raindex-interface-0.1.8/src/interface/IRaindexV6.sol";
+import {StateNamespace} from "rainlang-interface-0.2.13/src/interface/IInterpreterV4.sol";
+
+/// All information resulting from an order calculation that allows for vault IO
+/// to be calculated and applied, then the handle IO entrypoint to be dispatched.
+/// @param outputMax The maximum output calculated by the order expression as a
+/// Float. WILL BE RESCALED ACCORDING TO TOKEN DECIMALS (read via TOFU) for the
+/// purpose of calculating actual vault movements.
+/// The output max is CAPPED AT THE OUTPUT VAULT BALANCE OF THE ORDER OWNER.
+/// The order is guaranteed that the total output of this single clearance cannot
+/// exceed this (subject to rescaling). It is up to the order expression to track
+/// values over time if the output max is to impose a global limit across many
+/// transactions and counterparties.
+/// @param IORatio The order ratio as input/output from the perspective of the
+/// order, as a Float. As each counterparty's input is the other's output, the
+/// IORatio calculated by each order is inverse of its counterparty. IORatio is
+/// RESCALED ACCORDING TO TOKEN DECIMALS (read via TOFU) when applied to vault
+/// balances. I.e. a ratio of `1` is ALWAYS "one" as ECONOMIC EQUIVALENCE
+/// between two tokens, but this will be rescaled according to the decimals of
+/// the token. For example, if DAI and USDT have a ratio of `1` then in reality
+/// `1e12` DAI will move in the vault for every `1` USDT that moves, because DAI
+/// has `1e18` decimals per $1 peg and USDT has `1e6` decimals per $1 peg.
+/// @param context The entire 2D context array, initialized from the context
+/// passed into the order calculations and then populated with the order
+/// calculations and vault IO before being passed back to handle IO entrypoint.
+/// @param namespace The `StateNamespace` to be passed to the store for calculate
+/// IO state changes.
+/// @param kvs KVs returned from calculate order entrypoint to pass to the store
+/// before calling handle IO entrypoint.
+struct OrderIOCalculationV4 {
+    OrderV4 order;
+    uint256 outputIOIndex;
+    Float outputMax;
+    //solhint-disable-next-line var-name-mixedcase
+    Float IORatio;
+    bytes32[][] context;
+    StateNamespace namespace;
+    bytes32[] kvs;
+}

src/struct/TakeOrdersIO.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: LicenseRef-DCL-1.0
+// SPDX-FileCopyrightText: Copyright (c) 2020 Rain Open Source Software Ltd
+pragma solidity ^0.8.25;
+
+import {Float} from "rain-math-float-0.3.10/src/lib/LibDecimalFloat.sol";
+
+/// The input and output tokens shared by every order in a `takeOrders4` batch,
+/// and the taker IO still remaining to fill as the batch is processed.
+/// @param inputToken The input token every order in the batch must use.
+/// @param outputToken The output token every order in the batch must use.
+/// @param remainingTakerIO The taker IO left to fill across the batch.
+struct TakeOrdersIO {
+    address inputToken;
+    address outputToken;
+    Float remainingTakerIO;
+}

test/abstract/RaindexV6ArbOrderTaker.context.t.sol

@@ -15,7 +15,8 @@ import {
 } from "raindex-interface-0.1.8/src/interface/IRaindexV6.sol";
 import {IERC20} from "@openzeppelin-contracts-5.7.0/token/ERC20/IERC20.sol";
 import {IERC20Metadata} from "@openzeppelin-contracts-5.7.0/token/ERC20/extensions/IERC20Metadata.sol";
-import {StateNamespace, LibNamespace} from "../../src/concrete/raindex/RaindexV6.sol";
+import {StateNamespace} from "rainlang-interface-0.2.13/src/interface/IInterpreterV4.sol";
+import {LibNamespace} from "rainlang-interface-0.2.13/src/lib/ns/LibNamespace.sol";
 import {LibDecimalFloat} from "rain-math-float-0.3.10/src/lib/LibDecimalFloat.sol";
 
 contract RaindexV6ArbOrderTakerContextTest is RaindexV6ExternalRealTest {