Cross-chain governance - ZKsync Community Code

Call L2 Contract from L1

Now, let's call the increment method on Layer 2 from Layer 1.

Create a new file in the scripts folder named increment-counter.ts.

touch scripts/increment-counter.ts

Copy and paste in the following code, replacing the following details:

GOVERNANCE_ADDRESS: the address of the contract deployed in L1.
COUNTER_ADDRESS: the address of the contract deployed in L2.
<YOUR_L1_RPC_ENDPOINT>: your L1 RPC endpoint (if not deploying on a local node).

L2-counter/scripts/increment-counter.ts

import { ethers, network } from 'hardhat';
import { utils } from 'zksync-ethers';
import * as COUNTER_ABI_JSON from '../artifacts-zk/contracts/Counter.sol/Counter.json';
import * as GOVERNANCE_ABI_JSON from '../../L1-governance/artifacts/contracts/Governance.sol/Governance.json';
import { Wallet } from 'ethers';

const COUNTER_ADDRESS = process.env.COUNTER_ADDRESS ?? '<COUNTER_ADDRESS>';
const GOVERNANCE_ADDRESS = process.env.GOVERNANCE_ADDRESS ?? '<GOVERNANCE-ADDRESS>';

async function main() {
  // Set up the Governor wallet to be the same as the one that deployed the governance contract.
  const [wallet] = await ethers.getWallets();

  // Initialize the L2 provider.
  const l2Provider = ethers.providerL2;

  // Initialize the L1 provider.
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const networkInfo = network as any;
  const l1RPCEndpoint =
    networkInfo.config.ethNetwork === 'http://localhost:8545'
      ? networkInfo.config.ethNetwork
      : '<YOUR_L1_RPC_ENDPOINT>';
  const l1Provider = new ethers.Provider(l1RPCEndpoint);

  // Encoding the L1 transaction is done in the same way as it is done on Ethereum.
  // Use an Interface which gives access to the contract functions.
  const counterInterface = new ethers.Interface(COUNTER_ABI_JSON.abi);
  const data = counterInterface.encodeFunctionData('increment', []);

  // The price of an L1 transaction depends on the gas price used.
  // You should explicitly fetch the gas price before making the call.
  const gasPrice = await l1Provider.getGasPrice();

  // Define a constant for gas limit which estimates the limit for the L1 to L2 transaction.
  const gasLimit = await l2Provider.estimateL1ToL2Execute({
    contractAddress: COUNTER_ADDRESS,
    calldata: data,
    caller: utils.applyL1ToL2Alias(GOVERNANCE_ADDRESS),
  });

  // Get the current address of the ZKsync L1 Bridge Hub.
  const bridgeHubAddress = await l2Provider.getBridgehubContractAddress();

  const l1ConnectedWallet = new Wallet(wallet.privateKey, l1Provider);
  // Get the `Contract` object of the ZKsync Bridge Hub.
  const bridgeHubContract = new ethers.Contract(bridgeHubAddress, utils.BRIDGEHUB_ABI, l1ConnectedWallet);

  // Set a constant that accesses the Layer 1 governance contract.
  const govcontract = new ethers.Contract(GOVERNANCE_ADDRESS, GOVERNANCE_ABI_JSON.abi, l1ConnectedWallet);

  // Get the L2 chain ID
  const chainId = (await l2Provider.getNetwork()).chainId;

  // Get the base cost of the transaction.
  const baseCost = await bridgeHubContract.l2TransactionBaseCost(
    chainId,
    gasPrice,
    gasLimit,
    utils.REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT
  );

  // Call the governance contract to increment the counter.
  const l2Response = await govcontract.callZkSync(
    chainId,
    bridgeHubAddress,
    COUNTER_ADDRESS,
    data,
    gasLimit,
    utils.REQUIRED_L1_TO_L2_GAS_PER_PUBDATA_LIMIT,
    baseCost,
    { gasPrice, value: baseCost }
  );
  const l2Receipt = await l2Response.wait();
  console.log(l2Receipt);
  console.log(l2Receipt.status === 1 ? 'Successfully incremented the counter' : 'Transaction failed');
}

// We recommend always using this async/await pattern to properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Executing transactions from L1 requires the caller to pay a fee to the L2 operator. The fee depends on the length of the calldata and the gasLimit. This is similar to the gasLimit on Ethereum.You can read more about the ZKsync fee model here. The fee also depends on the gas price that is used during the transaction call. So to have a predictable fee for the call, the gas price should be fetched from the L1 provider.

Run the script with the following command:

npx hardhat run ./scripts/increment-counter.ts

In the output, you should see the full transaction receipt in L2. You can take the transactionHash and track it in the ZKsync explorer. It should look something like this:

{
  to: '0x9b379893bfAD08c12C2167C3e3dBf591BeD9410a',
  from: '0xE2EA97507a6cb610c81c4A9c157B8060E2ED7036',
  contractAddress: null,
  transactionIndex: 0,
  root: '0xb9ca78c288163a322a797ee671db8e9ab430eb00e38c4a989f2246ea22493945',
  gasUsed: BigNumber { _hex: '0x05c3df', _isBigNumber: true },
  logsBloom: '0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
  blockHash: '0xb9ca78c288163a322a797ee671db8e9ab430eb00e38c4a989f2246ea22493945',
  transactionHash: '0x1fb19cc0aca8fcccaf5fbafd9174550f3151d0d2aa15d99eb820e0394313e409',
  logs: [
    {
      transactionIndex: 0,
      blockNumber: 4119331,
      transactionHash: '0x1fb19cc0aca8fcccaf5fbafd9174550f3151d0d2aa15d99eb820e0394313e409',
      address: '0x000000000000000000000000000000000000800A',
      topics: [Array],
      ...

Verify that the transaction was successful by running the display-value script again. You may have to wait a couple minutes for the counter to update.
```
npx hardhat run ./scripts/display-value.ts
```
You should see an incremented value in the output:
```
The counter value is 1
```

Learn More

To learn more about L1->L2 interaction on ZKsync, check out the documentation.
To learn more about the zksync-ethers SDK, check out its documentation.
To learn more about the ZKsync hardhat plugins, check out their documentation.

L2 counter contract

L1-L2 transactions

Call L2 Contract from L1

Learn More