Merge pull request #383 from OffchainLabs/contract-size

Contract size

Author: rory-ocl

cargo-stylus/src/commands/deploy.rs

@@ -12,7 +12,7 @@ use crate::{
 };
 use alloy::primitives::{utils::parse_ether, Address, B256, U256};
 use eyre::eyre;
-use stylus_tools::core::deployment::deploy_wasm_file;
+use stylus_tools::core::deployment;
 use stylus_tools::core::deployment::deployer::ADDRESS;
 
 pub const STYLUS_DEPLOYER_ADDRESS: Address = ADDRESS;
@@ -87,18 +87,28 @@ pub async fn exec(args: Args) -> CargoStylusResult {
         &args.build,
         &args.check,
         args.auth.get_max_fee_per_gas_wei()?,
-        args.estimate_gas,
         args.no_activate,
         args.deployer_address,
         args.constructor_args,
         args.deployer_salt,
         args.constructor_value,
     );
-    if let Some(wasm_file) = args.wasm_file {
-        deploy_wasm_file(wasm_file, &config, &provider).await?;
+    #[allow(clippy::collapsible_else_if)]
+    if args.estimate_gas {
+        if let Some(wasm_file) = args.wasm_file {
+            let _gas = deployment::estimate_gas_wasm_file(wasm_file, &config, &provider).await?;
+        } else {
+            for contract in contracts {
+                let _gas = deployment::estimate_gas(&contract, &config, &provider).await?;
+            }
+        }
     } else {
-        for contract in contracts {
-            contract.deploy(&config, &provider).await?;
+        if let Some(wasm_file) = args.wasm_file {
+            deployment::deploy_wasm_file(wasm_file, &config, &provider).await?;
+        } else {
+            for contract in contracts {
+                contract.deploy(&config, &provider).await?;
+            }
         }
     }
     Ok(())

cargo-stylus/src/commands/get_initcode.rs

@@ -31,9 +31,16 @@ pub fn exec(args: Args) -> CargoStylusResult {
         None => &mut io::stdout(),
     };
     let build_config = args.build.config();
+    let chain_config = Default::default();
     let project_config = args.project.config();
     for contract in args.project.contracts()? {
-        ops::write_initcode(&contract, &build_config, &project_config, &mut *writer)?;
+        ops::write_initcode(
+            &contract,
+            &build_config,
+            &chain_config,
+            &project_config,
+            &mut *writer,
+        )?;
     }
     Ok(())
 }

cargo-stylus/src/common_args.rs

@@ -151,7 +151,6 @@ impl DeployArgs {
         build: &BuildArgs,
         check: &CheckArgs,
         max_fee_per_gas_gwei: Option<u128>,
-        estimate_gas: bool,
         no_activate: bool,
         deployer_address: Address,
         constructor_args: Vec<String>,
@@ -161,7 +160,6 @@ impl DeployArgs {
         DeploymentConfig {
             check: check.config(activate, build),
             max_fee_per_gas_gwei,
-            estimate_gas,
             no_activate,
             deployer_address,
             constructor_args,

stylus-tools/precompiles/ArbOwner.sol

@@ -209,6 +209,12 @@ interface ArbOwner {
         bool enable
     ) external;
 
+    /// @notice Sets the max amount of stylus contract fragments that can be used to deploy a stylus contract
+    /// @notice Available in ArbOS version 60 and above
+    function setMaxStylusContractFragments(
+        uint8 maxFragments
+    ) external;
+
     /// Emitted when a successful call is made to this precompile
     event OwnerActs(bytes4 indexed method, address indexed owner, bytes data);
 }

stylus-tools/precompiles/ArbOwnerPublic.sol

@@ -44,5 +44,9 @@ interface ArbOwnerPublic {
     /// Available in ArbOS version 40 with default as false
     function isCalldataPriceIncreaseEnabled() external view returns (bool);
 
+    /// @notice Get the max amount of stylus contract fragments that can be used to deploy a stylus contract
+    /// @notice Available in ArbOS version 60 and above
+    function getMaxStylusContractFragments() external view returns (uint8);
+
     event ChainOwnerRectified(address rectifiedOwner);
 }

stylus-tools/src/core/activation.rs

@@ -7,7 +7,7 @@
 //! details on contract activation.
 
 use alloy::{
-    primitives::{utils::parse_ether, Address, Bytes, U256},
+    primitives::{utils::parse_ether, Address, U256},
     providers::{Provider, WalletProvider},
     rpc::types::{
         state::{AccountOverride, StateOverride},
@@ -16,6 +16,7 @@ use alloy::{
 };
 
 use crate::{
+    core::code::contract::ContractCode,
     precompiles,
     utils::{
         bump_data_fee,
@@ -24,6 +25,8 @@ use crate::{
     },
 };
 
+use super::code::Code;
+
 #[derive(Debug)]
 pub struct ActivationConfig {
     pub data_fee_bump_percent: u64,
@@ -71,7 +74,7 @@ pub async fn activate_contract(
 ) -> Result<TransactionReceipt, ActivationError> {
     let code = provider.get_code_at(address).await?;
     let from_address = provider.default_signer_address();
-    let data_fee = data_fee(code, address, config, &provider).await?;
+    let data_fee = data_fee(&Code::new_from_code(&code), address, config, &provider).await?;
 
     let receipt = precompiles::arb_wasm(&provider)
         .activateProgram(address)
@@ -93,20 +96,41 @@ pub async fn activate_contract(
 
 /// Checks Stylus contract activation, returning the data fee.
 pub async fn data_fee(
-    code: impl Into<Bytes>,
+    code: &Code,
     address: Address,
     config: &ActivationConfig,
     provider: &impl Provider,
 ) -> Result<U256, ActivationError> {
     let arbwasm = precompiles::arb_wasm(provider);
     let random_sender_addr = Address::random();
     let spoofed_sender_account = AccountOverride::default().with_balance(U256::MAX);
-    let spoofed_code = AccountOverride::default().with_code(code);
-    let state_override = StateOverride::from_iter([
-        (address, spoofed_code),
-        (random_sender_addr, spoofed_sender_account),
-    ]);
+    let mut state_override = vec![(random_sender_addr, spoofed_sender_account)];
+
+    match code {
+        Code::Contract(contract) => {
+            let spoofed_code = AccountOverride::default().with_code(contract.as_slice().to_vec());
+            state_override.push((address, spoofed_code));
+        }
+        Code::Fragments(fragments) => {
+            let fragment_addresses = fragments.as_slice().iter().map(|fragment| {
+                let fragment_address = Address::random();
+                let fragment_code =
+                    AccountOverride::default().with_code(fragment.as_slice().to_vec());
+                state_override.push((fragment_address, fragment_code));
+                fragment_address
+            });
+            let root_contract = ContractCode::new_root_contract(
+                fragments.uncompressed_wasm_size(),
+                fragment_addresses,
+            );
+
+            let spoofed_code =
+                AccountOverride::default().with_code(root_contract.as_slice().to_vec());
+            state_override.push((address, spoofed_code));
+        }
+    }
 
+    let state_override = StateOverride::from_iter(state_override);
     let result = arbwasm
         .activateProgram(address)
         .state(state_override)
@@ -135,7 +159,7 @@ pub async fn estimate_gas(
 ) -> Result<u64, ActivationError> {
     let code = provider.get_code_at(address).await?;
     let from_address = provider.default_signer_address();
-    let data_fee = data_fee(code, address, config, &provider).await?;
+    let data_fee = data_fee(&Code::new_from_code(&code), address, config, &provider).await?;
 
     let gas = precompiles::arb_wasm(&provider)
         .activateProgram(address)

stylus-tools/src/core/chain.rs

@@ -0,0 +1,18 @@
+// Copyright 2025, Offchain Labs, Inc.
+// For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md
+
+/// Maximum code size per EIP-170
+pub const DEFAULT_MAX_CODE_SIZE: u64 = 24_576;
+
+#[derive(Debug)]
+pub struct ChainConfig {
+    pub max_code_size: u64,
+}
+
+impl Default for ChainConfig {
+    fn default() -> Self {
+        Self {
+            max_code_size: DEFAULT_MAX_CODE_SIZE,
+        }
+    }
+}

stylus-tools/src/core/check.rs

@@ -10,19 +10,25 @@ use crate::{
     core::{
         activation::{self, ActivationConfig},
         build::{build_contract, BuildConfig},
+        code::{
+            wasm::{compress_wasm, process_wasm_file},
+            Code,
+        },
         project::{
             contract::{Contract, ContractStatus},
             hash_project, ProjectConfig, ProjectHash,
         },
     },
     utils::format_file_size,
-    wasm::process_wasm_file,
 };
 
+use super::chain::ChainConfig;
+
 #[derive(Debug, Default)]
 pub struct CheckConfig {
     pub activation: ActivationConfig,
     pub build: BuildConfig,
+    pub chain: ChainConfig,
     pub project: ProjectConfig,
 }
 
@@ -42,7 +48,7 @@ pub enum CheckError {
     #[error("{0}")]
     Project(#[from] crate::core::project::ProjectError),
     #[error("{0}")]
-    ProcessWasm(#[from] crate::wasm::ProcessWasmFileError),
+    Wasm(#[from] crate::core::code::wasm::WasmError),
 }
 
 /// Checks that a contract is valid and can be deployed onchain.
@@ -70,29 +76,39 @@ pub async fn check_wasm_file(
 ) -> Result<ContractStatus, CheckError> {
     debug!(@grey, "reading wasm file at {}", wasm_file.as_ref().to_string_lossy().lavender());
     let processed = process_wasm_file(wasm_file, project_hash)?;
-    info!(@grey, "contract size: {}", format_file_size(ByteSize::b(processed.code.len() as u64), ByteSize::kib(16), ByteSize::kib(24)));
-    debug!(@grey, "wasm size: {}", format_file_size(ByteSize::b(processed.wasm.len() as u64), ByteSize::kib(96), ByteSize::kib(128)));
+    let compressed = compress_wasm(&processed)?;
+    let code = Code::split_if_large(
+        &compressed,
+        processed.len() as u32,
+        config.chain.max_code_size,
+    );
+    match &code {
+        Code::Contract(c) => {
+            info!(@grey, "contract size: {}", format_file_size(ByteSize::b(c.codesize() as u64), ByteSize::kib(16), ByteSize::kib(24)));
+        }
+        Code::Fragments(fs) => {
+            info!(@grey, "contract size: {} ({} fragments)", format_file_size(ByteSize::b(fs.codesize() as u64), ByteSize::kib(16), ByteSize::kib(24)), fs.fragment_count());
+        }
+    }
+    debug!(@grey, "wasm size: {}", format_file_size(ByteSize::b(processed.len() as u64), ByteSize::kib(96), ByteSize::kib(128)));
 
     // Check if the contract already exists
     // TODO: check log
     debug!(@grey, "connecting to RPC: {:?}", provider.root());
-    let codehash = processed.codehash();
-    if Contract::exists(codehash, &provider).await? {
-        return Ok(ContractStatus::Active {
-            code: processed.code,
-        });
+    if let Some(codehash) = code.codehash() {
+        if Contract::exists(codehash, &provider).await? {
+            return Ok(ContractStatus::Active {
+                code,
+                wasm: processed,
+            });
+        }
     }
 
     let contract_address = contract_address.unwrap_or_else(Address::random);
-    let fee = activation::data_fee(
-        processed.code.clone(),
-        contract_address,
-        &config.activation,
-        provider,
-    )
-    .await?;
+    let fee = activation::data_fee(&code, contract_address, &config.activation, provider).await?;
     Ok(ContractStatus::Ready {
-        code: processed.code,
+        code,
         fee,
+        wasm: processed,
     })
 }

stylus-tools/src/core/code/contract.rs

@@ -0,0 +1,55 @@
+// Copyright 2026, Offchain Labs, Inc.
+// For licensing, see https://github.com/OffchainLabs/stylus-sdk-rs/blob/main/licenses/COPYRIGHT.md
+
+use alloy::primitives::{keccak256, Address, B256};
+
+use crate::core::code::{prefixes, wasm::CompressedWasm};
+
+/// Code for a contract which fits within MAX_CODE_SIZE
+#[derive(Debug)]
+pub struct ContractCode(pub Vec<u8>);
+
+impl ContractCode {
+    pub fn new(wasm: &CompressedWasm) -> Self {
+        let mut code = Vec::with_capacity(prefixes::EOF_NO_DICT.len() + wasm.len());
+        code.extend(prefixes::EOF_NO_DICT);
+        code.extend(wasm.bytes());
+        Self(code)
+    }
+
+    pub fn new_root_contract(
+        uncompressed_wasm_size: u32,
+        addresses: impl IntoIterator<Item = Address>,
+    ) -> Self {
+        let serialized_wasm_size = uncompressed_wasm_size.to_be_bytes();
+        let addresses = addresses.into_iter();
+        let mut code = Vec::with_capacity(
+            prefixes::ROOT_NO_DICT.len()
+                + serialized_wasm_size.len()
+                + Address::len_bytes() * addresses.size_hint().1.unwrap_or(0),
+        );
+        code.extend(prefixes::ROOT_NO_DICT);
+        code.extend(serialized_wasm_size);
+        addresses.for_each(|a| code.extend(a));
+        Self(code)
+    }
+
+    pub fn new_from_code(code: &[u8]) -> Self {
+        Self(code.to_vec())
+    }
+
+    /// Get code bytes
+    pub fn as_slice(&self) -> &[u8] {
+        &self.0
+    }
+
+    /// Codehash is keccak256 hash of the code bytes
+    pub fn codehash(&self) -> B256 {
+        keccak256(&self.0)
+    }
+
+    /// Length of the contract code
+    pub fn codesize(&self) -> usize {
+        self.0.len()
+    }
+}