Contract Deployment

Unlike Ethereum, Abstract does not store the bytecode of smart contracts directly; instead, it stores a hash of the bytecode and publishes the bytecode itself to Ethereum.

This adds several benefits to smart contract deployments on Abstract, including:

• Inherited L1 Security: Smart contract bytecode is stored directly on Ethereum.
• Increased Gas efficiency: Only unique contract bytecode needs to be published on Ethereum. If you deploy the same contract more than once (such as when using a factory), subsequent contract deployments are substantially cheaper.

​

How Contract Deployment Works

Contracts cannot be deployed on Abstract unless the bytecode of the smart contract to be deployed is published on Ethereum. If the bytecode of the contract has not been published, the deployment transaction will fail with the error the code hash is not known.

To publish bytecode before deployment, all contract deployments on Abstract are performed by calling the ContractDeployer system contract using one of it’s create, create2, createAccount, or create2Account functions.

The bytecode of your smart contract and any other smart contracts that it can deploy (such as when using a factory) must be included inside the factory dependencies (factoryDeps) of the deployment transaction.

Typically, this process occurs under the hood and is performed by the compiler and client libraries. This page will show you how to deploy smart contracts on Abstract by interacting with the ContractDeployer system contract.

​

Get Started Deploying Smart Contracts

Use the example repository below as a reference for creating smart contracts and scripts that can deploy smart contracts on Abstract using various libraries.

​

Deploying Smart Contracts

When building smart contracts, the zksolc and zkvyper compilers transform calls to the CREATE and CREATE2 opcodes into calls to the create and create2 functions on the ContractDeployer system contract.

In addition, when you call either of these opcodes, the compiler automatically detects what other contracts your contract is capable of deploying and includes them in the factoryDeps field of the generated artifacts.

​

Solidity

No Solidity changes are required to deploy smart contracts, as the compiler handles the transformation automatically. Note: address derivation via CREATE and CREATE2 is different from Ethereum. Learn more.

​

create

Below are examples of how to write a smart contract that deploys other smart contracts using the CREATE opcode. The compiler will automatically transform these calls into calls to the create function on the ContractDeployer system contract.

​

create2

Below are examples of how to write a smart contract that deploys other smart contracts using the CREATE2 opcode. The compiler will automatically transform these calls into calls to the create2 function on the ContractDeployer system contract.

​

createAccount

When deploying smart contract wallets on Abstract, manually call the createAccount or create2Account function on the ContractDeployer system contract. This is required because the contract needs to be flagged as a smart contract wallet by setting the fourth argument of the createAccount function to the account abstraction version.

​

create2Account

Similar to the createAccount function, the create2Account function on the ContractDeployer system contract must be called manually when deploying smart contract wallets on Abstract to flag the contract as a smart contract wallet by setting the fourth argument of the create2Account function to the account abstraction version.

​

EIP-712 Transactions via Clients

Once your smart contracts are compiled and you have the bytecode(s), you can use various client libraries to deploy your smart contracts by creating EIP-712 transactions that:

• Have the transaction type set to 113 (to indicate an EIP-712 transaction).
• Call the create, create2, createAccount, or create2Account function to the ContractDeployer system contract address (0x0000000000000000000000000000000000008006).
• Include the bytecode of the smart contract and any other contracts it can deploy in the customData.factoryDeps field of the transaction.

​

hardhat-zksync

Since the compiler automatically generates the factoryDeps field for you in the contract artifact (unless you are manually calling the ContractDeployer via createAccount or create2Account functions), load the artifact of the contract and use the Deployer class from the hardhat-zksync plugin to deploy the contract.

​

zksync-ethers

Use the ContractFactory class from the zksync-ethers library to deploy your smart contracts.

​

viem

Use Viem’s deployContract method to deploy your smart contracts.

​

How Bytecode Publishing Works

When a contract is deployed on Abstract, multiple system contracts work together to compress and publish the contract bytecode to Ethereum before the contract is deployed.

Once the bytecode is published, the hash of the bytecode is set to “known”; meaning the contract can be deployed on Abstract without needing to publish the bytecode again.

The process can be broken down into the following steps:

/// @notice Deploys a contract with similar address derivation rules to the EVM's `CREATE` opcode.
/// @param _bytecodeHash The correctly formatted hash of the bytecode.
/// @param _input The constructor calldata
/// @dev This method also accepts nonce as one of its parameters.
/// It is not used anywhere and it needed simply for the consistency for the compiler
/// Note: this method may be callable only in system mode,
/// that is checked in the `createAccount` by `onlySystemCall` modifier.
function create(
    bytes32 _salt,
    bytes32 _bytecodeHash,
    bytes calldata _input
) external payable override returns (address) {
  // ...
}