chore(solidity): adapt bytecode size gate to Sapphire 64 KiB limit

Sapphire's contract-size limit is being raised to 64 KiB. Split the size
check by deployment target: Sapphire-side contracts (Accounting plus its
delegatecall modules and library) cap at 64 KiB, while the Base-side bridge
contracts (XRose, ROFLBridge) stay on the EIP-170 24576-byte cap. Hold a 1 KiB
buffer below each limit, so enforced caps are 64512 (Sapphire) and 23552 (Base).

Replace the project-internal Accounting target and the now-redundant Accounting
headroom floor with the uniform buffer, and drop the stale optimizer-runs comment.

Author: rube-de

solidity/hardhat.config.ts

@@ -50,7 +50,6 @@ const config: HardhatUserConfig = {
       evmVersion: 'paris',
       optimizer: {
         enabled: true,
-        // Keep bytecode size below EIP-170 limits; large "runs" can bloat size significantly.
         runs: 20,
       },
       viaIR: true,

solidity/scripts/.bytecode-baseline.json

@@ -23,7 +23,5 @@
       "size": 16893
     }
   },
-  "headroomFloor": {
-    "Accounting": 200
-  }
+  "headroomFloor": {}
 }

solidity/scripts/check-bytecode-size.ts

@@ -2,12 +2,38 @@ import { artifacts } from "hardhat";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 
-const EIP170_LIMIT_BYTES = 24576;
-// Project-internal Accounting cap, well below EIP-170. Each new bridge
-// selector in `Accounting.fallback`'s allowlist costs ~23 B; leave room for
-// ~30+ more selectors before the next bump. Paired with the per-contract
-// headroom floor in `.bytecode-baseline.json::headroomFloor.Accounting`.
-const ACCOUNTING_TARGET_BYTES = 23800;
+// Per-chain contract-size limits enforced by each deploy target. Sapphire
+// allows 64 KiB; Base and other standard EVM chains stay at the EIP-170
+// 24576-byte cap.
+const SAPPHIRE_LIMIT_BYTES = 65536; // 64 KiB
+const EIP170_LIMIT_BYTES = 24576; // standard EVM (Base, etc.)
+
+// Safety buffer held below each contract's real limit so nothing is ever
+// deployed right at the hard ceiling. The enforced cap is `limit - buffer`.
+const SIZE_BUFFER_BYTES = 1024; // 1 KiB
+
+// Per-contract real limits; `required: true` makes a missing artifact a hard
+// failure (a rename/build regression), not a silent skip.
+const CONTRACTS: ReadonlyArray<{
+  name: string;
+  limit: number;
+  required: boolean;
+}> = [
+  // Sapphire-side: Accounting and its delegatecall modules/library.
+  { name: "Accounting", limit: SAPPHIRE_LIMIT_BYTES, required: true },
+  {
+    name: "AccountingHistoryModule",
+    limit: SAPPHIRE_LIMIT_BYTES,
+    required: true,
+  },
+  { name: "BridgeModule", limit: SAPPHIRE_LIMIT_BYTES, required: true },
+  { name: "LockModule", limit: SAPPHIRE_LIMIT_BYTES, required: true },
+  { name: "BridgeLib", limit: SAPPHIRE_LIMIT_BYTES, required: true },
+  // Base-side (base-sepolia, chainId 84532): standard EIP-170, NOT raised.
+  // Optional — skipped silently until their artifacts exist.
+  { name: "XRose", limit: EIP170_LIMIT_BYTES, required: false },
+  { name: "ROFLBridge", limit: EIP170_LIMIT_BYTES, required: false },
+];
 
 const BASELINE_PATH = path.join(__dirname, ".bytecode-baseline.json");
 
@@ -162,20 +188,11 @@ async function main() {
     );
   }
 
-  // Hard targets first — Accounting must stay under the project-internal
-  // ceiling. Accounting, BridgeModule, and BridgeLib are permanent: a
-  // missing artifact for any of them is a hard failure (likely a
-  // rename/build regression), not a silent skip.
-  const results = [
-    await check("Accounting", ACCOUNTING_TARGET_BYTES, baseline, true),
-    await check("AccountingHistoryModule", EIP170_LIMIT_BYTES, baseline, true),
-    await check("BridgeModule", EIP170_LIMIT_BYTES, baseline, true),
-    await check("LockModule", EIP170_LIMIT_BYTES, baseline, true),
-    await check("BridgeLib", EIP170_LIMIT_BYTES, baseline, true),
-    // Optional bridge contracts; skipped silently until their artifacts exist.
-    await check("XRose", EIP170_LIMIT_BYTES, baseline, false),
-    await check("ROFLBridge", EIP170_LIMIT_BYTES, baseline, false),
-  ];
+  const results = await Promise.all(
+    CONTRACTS.map((c) =>
+      check(c.name, c.limit - SIZE_BUFFER_BYTES, baseline, c.required),
+    ),
+  );
 
   if (updateMode) {
     await updateBaseline(results);