Merge pull request #128 from OffchainLabs/update-tutorials-4

Update tutorials to ArbSDK v4 (4)

Author: TucksonDev

README.md

@@ -32,7 +32,7 @@ yarn install
 
 - 🤝 [Greeter](./packages/greeter/) (parent to child messages)
 - 📤 [Outbox](./packages/outbox-execute/) (child to parent messages)
-- ⏰ [L1 Confirmation Checker](./packages/l1-confirmation-checker/)
+- ⏰ [Parent chain confirmation checker](./packages/parent-chain-confirmation-checker/)
 - ⏰ [L2 block verification in assertion](./packages/l2-block-verification-in-assertion/)
 
 #### :white_check_mark: Advanced features
@@ -42,6 +42,7 @@ yarn install
 - 🌉 [Bridging a custom token through a custom gateway](./packages/custom-gateway-bridging/)
 - ✈️ [Send a signed transaction from the parent chain](./packages/delayedInbox-l2msg/)
 - 🎁 [Redeem Retryable Ticket](./packages/redeem-failed-retryable/)
+- 🧮 [Gas estimation](./packages/gas-estimation/)
 - 🌀 [Deposit Ether or Tokens from L1 to L3](./packages/l1-l3-teleport/)
 
 ## How to run the tutorials against a custom network

packages/gas-estimation/.env-sample

@@ -1,3 +1,6 @@
-# Hosted Aggregator Node (JSON-RPC Endpoint). This is Arbitrum Sepolia Testnet, can use any Arbitrum chain
+# This is a sample .env file for use in local development.
+# Duplicate this file as .env here
 
-L2RPC="https://sepolia-rollup.arbitrum.io/rpc"
+# The main chain's RPC
+# (this can be an Arbitrum network, or your Orbit chain)
+CHAIN_RPC="https://sepolia-rollup.arbitrum.io/rpc"

packages/gas-estimation/README.md

@@ -2,27 +2,31 @@
 
 `gas-estimation` is a simple demo of how a developer can estimate transaction fees on Arbitrum.
 
-It uses the formula described in this Medium article to estimate the fees to be paid on a transaction, also estimating each component of the formula sepparately: [Understanding Arbitrum: 2-Dimensional Fees](https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9).
+It uses the formula described in this Medium article to estimate the fees to be paid on a transaction, also estimating each component of the formula sepparately: [Understanding Arbitrum: 2-Dimensional Fees](https://medium.com/offchainlabs/understanding-arbitrum-2-dimensional-fees-fd1d582596c9). For more information, you can also see [How to estimate gas](https://docs.arbitrum.io/build-decentralized-apps/how-to-estimate-gas) in the Arbitrum documentation portal.
 
 See [./exec.ts](./scripts/exec.ts) for inline explanations.
 
-Inside the script, you can edit `txData` constant to suit your needs.
-
-To run:
-
-```
-yarn run exec
-```
-
-## Config Environment Variables
+## Set environment variables
 
 Set the values shown in `.env-sample` as environmental variables. To copy it into a `.env` file:
 
 ```bash
 cp .env-sample .env
 ```
 
-(you'll still need to edit some variables, i.e., `L2RPC`)
+You'll still need to edit some variables, i.e., `CHAIN_RPC`.
+
+Note that you can also set the environment variables in an `.env` file in the root of the monorepo, which will be available in all tutorials.
+
+## Run
+
+Inside the script, you can edit the `txData` constant to suit your needs.
+
+To run:
+
+```
+yarn run exec
+```
 
 <p align="left">
   <img width="350" height="150" src= "../../assets/logo.svg" />

packages/gas-estimation/package.json

@@ -1,15 +1,13 @@
 {
   "name": "gas-estimation",
+  "license": "Apache-2.0",
   "version": "1.0.0",
-  "description": "",
   "scripts": {
     "exec": "ts-node scripts/exec.ts"
   },
   "dependencies": {
-    "@arbitrum/sdk": "^v3.1.9",
-    "ts-node": "^10.8.1",
-    "typescript": "^4.7.3"
-  },
-  "author": "",
-  "license": "ISC"
+    "@arbitrum/sdk": "^v4.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^4.9.5"
+  }
 }

packages/gas-estimation/scripts/exec.ts

@@ -1,15 +1,14 @@
 import { utils, providers } from "ethers";
-import { addDefaultLocalNetwork } from "@arbitrum/sdk";
 import { NodeInterface__factory } from "@arbitrum/sdk/dist/lib/abi/factories/NodeInterface__factory";
 import { NODE_INTERFACE_ADDRESS } from "@arbitrum/sdk/dist/lib/dataEntities/constants";
-const { requireEnvVariables } = require('arb-shared-dependencies');
+const { requireEnvVariables, addCustomNetworkFromFile } = require('arb-shared-dependencies');
 
 // Importing configuration //
 require('dotenv').config();
-requireEnvVariables(['L2RPC']);
+requireEnvVariables(['CHAIN_RPC']);
 
 // Initial setup //
-const baseL2Provider = new providers.StaticJsonRpcProvider(process.env.L2RPC);
+const provider = new providers.StaticJsonRpcProvider(process.env.CHAIN_RPC);
 
 ///////////////////////////////////////////
 // Values of the transaction to estimate //
@@ -29,6 +28,9 @@ const gasEstimator = async () => {
     // * Gas formula explanation *
     // ***************************
     //
+    // NOTE: In this explanation, L1 and L2 terms are used to represent the Layer-1 and Layer-2 components.
+    //       For L3 Orbit chains, L1 should be viewed as the parent chain (Layer 2), and L2 as the orbit chain (L3)
+    //
     // Transaction fees (TXFEES) = L2 Gas Price (P) * Gas Limit (G)
     //      ----> Gas Limit (G) = L2 Gas used (L2G) + Extra Buffer for L1 cost (B)
     //      ----> L1 Estimated Cost (L1C) = L1 estimated calldata price per byte (L1P) * L1 Calldata size in bytes (L1S)
@@ -45,13 +47,13 @@ const gasEstimator = async () => {
     //      NodeInterface.GasEstimateComponents() and get the third element => result[2]
     // L2G (L2 Gas used) => Will depend on the transaction itself
     // L1P (L1 estimated calldata price per byte) =>
-    //      (this is the L2's estimated view of the current L1's price per byte of data, which the L2 dynamically adjusts over time)
+    //      (this is the child-chain's estimated view of the current parent-chain's price per byte of data, which the child-chain dynamically adjusts over time)
     //      ArbGasInfo.getL1BaseFeeEstimate() and multiply by 16
     //      ArbGasInfo.getL1GasPriceEstimate() and multiply by 16
     //      ArbGasInfo.getPricesInWei() and get the second element => result[1]
     //      NodeInterface.GasEstimateL1Component() and get the third element and multiply by 16 => result[2]*16
     //      NodeInterface.GasEstimateComponents() and get the fourth element and multiply by 16 => result[3]*16
-    // L1S (Size in bytes of the calldata to post on L1) =>
+    // L1S (Size in bytes of the calldata to post on the parent chain) =>
     //      Will depend on the size (in bytes) of the calldata of the transaction
     //      We add a fixed amount of 140 bytes to that amount for the transaction metadata (recipient, nonce, gas price, ...)
     //      Final size will be less after compression, but this calculation gives a good estimation
@@ -64,14 +66,13 @@ const gasEstimator = async () => {
     //      NodeInterface.GasEstimateComponents() and get the second element => result[1]
     //
 
-    // Add the default local network configuration to the SDK
-    // to allow this script to run on a local node
-    addDefaultLocalNetwork()
+    // dd the custom network configuration to the SDK if present
+    addCustomNetworkFromFile()
 
     // Instantiation of the NodeInterface object
     const nodeInterface = NodeInterface__factory.connect(
         NODE_INTERFACE_ADDRESS,
-        baseL2Provider
+        provider
     );
 
     // Getting the estimations from NodeInterface.GasEstimateComponents()
@@ -86,26 +87,26 @@ const gasEstimator = async () => {
     );
 
     // Getting useful values for calculating the formula
-    const l1GasEstimated = gasEstimateComponents.gasEstimateForL1;
-    const l2GasUsed = gasEstimateComponents.gasEstimate.sub(gasEstimateComponents.gasEstimateForL1);
-    const l2EstimatedPrice = gasEstimateComponents.baseFee;
-    const l1EstimatedPrice = gasEstimateComponents.l1BaseFeeEstimate.mul(16);
+    const parentChainGasEstimated = gasEstimateComponents.gasEstimateForL1;
+    const childChainGasUsed = gasEstimateComponents.gasEstimate.sub(gasEstimateComponents.gasEstimateForL1);
+    const childChainEstimatedPrice = gasEstimateComponents.baseFee;
+    const parentChainEstimatedPrice = gasEstimateComponents.l1BaseFeeEstimate.mul(16);
 
 
     // Calculating some extra values to be able to apply all variables of the formula
     // -------------------------------------------------------------------------------
-    // NOTE: This one might be a bit confusing, but l1GasEstimated (B in the formula) is calculated based on l2 gas fees
-    const l1Cost = l1GasEstimated.mul(l2EstimatedPrice);
+    // NOTE: This one might be a bit confusing, but parentChainGasEstimated (B in the formula) is calculated based on child-chain's gas fees
+    const parentChainCost = parentChainGasEstimated.mul(childChainEstimatedPrice);
     // NOTE: This is similar to 140 + utils.hexDataLength(txData);
-    const l1Size = l1Cost.div(l1EstimatedPrice);
+    const parentChainSize = parentChainCost.div(parentChainEstimatedPrice);
 
     // Getting the result of the formula
     // ---------------------------------
     // Setting the basic variables of the formula
-    const P = l2EstimatedPrice;
-    const L2G = l2GasUsed;
-    const L1P = l1EstimatedPrice;
-    const L1S = l1Size;
+    const P = childChainEstimatedPrice;
+    const L2G = childChainGasUsed;
+    const L1P = parentChainEstimatedPrice;
+    const L1S = parentChainSize;
 
     // L1C (L1 Cost) = L1P * L1S
     const L1C = L1P.mul(L1S);
@@ -122,12 +123,12 @@ const gasEstimator = async () => {
     console.log("Gas estimation components");
     console.log("-------------------");
     console.log(`Full gas estimation = ${gasEstimateComponents.gasEstimate.toNumber()} units`);
-    console.log(`L2 Gas (L2G) = ${L2G.toNumber()} units`);
-    console.log(`L1 estimated Gas (L1G) = ${l1GasEstimated.toNumber()} units`);
+    console.log(`Child chain Gas (L2G) = ${L2G.toNumber()} units`);
+    console.log(`Parent chain estimated Gas (L1G) = ${parentChainGasEstimated.toNumber()} units`);
 
-    console.log(`P (L2 Gas Price) = ${utils.formatUnits(P, "gwei")} gwei`);
-    console.log(`L1P (L1 estimated calldata price per byte) = ${utils.formatUnits(L1P, "gwei")} gwei`);
-    console.log(`L1S (L1 Calldata size in bytes) = ${L1S} bytes`);
+    console.log(`P (Child chain gas price) = ${utils.formatUnits(P, "gwei")} gwei`);
+    console.log(`L1P (Parent chain estimated calldata price per byte) = ${utils.formatUnits(L1P, "gwei")} gwei`);
+    console.log(`L1S (Parent chain calldata size in bytes) = ${L1S} bytes`);
 
     console.log("-------------------");
     console.log(`Transaction estimated fees to pay = ${utils.formatEther(TXFEES)} ETH`);

packages/greeter/.env-sample

@@ -1,15 +1,13 @@
 # This is a sample .env file for use in local development.
-
 # Duplicate this file as .env here
 
-# Your Private key
-
-DEVNET_PRIVKEY="0x your key here"
-
-# Hosted Aggregator Node (JSON-RPC Endpoint). This is Arbitrum Sepolia Testnet, can use any Arbitrum chain
-
-L2RPC="https://sepolia-rollup.arbitrum.io/rpc"
+# Your private key
+PRIVATE_KEY="0x your key here"
 
-# Ethereum RPC; i.e., for Sepolia https://sepolia.infura.io/v3/<your infura key>
+# The main chain's RPC
+# (this can be an Arbitrum network, or your Orbit chain)
+CHAIN_RPC="https://sepolia-rollup.arbitrum.io/rpc"
 
-L1RPC=""
+# The parent chain's RPC
+# (this can be Ethereum, or the chain your Orbit chain settles to)
+PARENT_CHAIN_RPC="https://sepolia.infura.io/v3/<your infura key>"

packages/greeter/.gitignore

@@ -1,30 +1,34 @@
-# Greeter Tutorial
+# Greeter tutorial
 
-`greeter` is a simple demo of Arbitrum's L1-to-L2 message passing system (aka "retryable tickets").
+`greeter` is a simple demo of Arbitrum's Parent-to-child message passing system (aka "L1-to-L2" or "retryable tickets").
 
-It deploys 2 contracts - one to L1, and another to L2, and has the L1 contract send a message to the L2 contract to be executed automatically.
+It deploys 2 contracts - one to the parent chain, and another to the child chain, and has the parent chain contract send a message to the child chain contract to be executed automatically.
 
-The script and contracts demonstrate how to interact with Arbitrum's core bridge contracts to create these retryable messages, how to calculate and forward appropriate fees from L1 to L2, and how to use Arbitrum's L1-to-L2 message [address aliasing](https://developer.offchainlabs.com/docs/l1_l2_messages#address-aliasing).
+The script and contracts demonstrate how to interact with Arbitrum's core bridge contracts to create these retryable messages, how to calculate and forward appropriate fees from parent to child, and how to use Arbitrum's Parent-to-child message [address aliasing](https://docs.arbitrum.io/how-arbitrum-works/arbos/l1-l2-messaging#address-aliasing).
 
 See [./exec.js](./scripts/exec.js) for inline explanation.
 
-[Click here](https://developer.offchainlabs.com/docs/l1_l2_messages) for more info on retryable tickets.
+[Click here](https://docs.arbitrum.io/how-arbitrum-works/arbos/l1-l2-messaging) for more info on retryable tickets.
 
-### Run Demo:
-
-```
-yarn run greeter
-```
-
-## Config Environment Variables
+## Set environment variables
 
 Set the values shown in `.env-sample` as environmental variables. To copy it into a `.env` file:
 
 ```bash
 cp .env-sample .env
 ```
 
-(you'll still need to edit some variables, i.e., `DEVNET_PRIVKEY`)
+You'll still need to edit some variables, i.e., `PRIVATE_KEY`, `CHAIN_RPC` and `PARENT_CHAIN_RPC`.
+
+Note that you can also set the environment variables in an `.env` file in the root of the monorepo, which will be available in all tutorials.
+
+## Run
+
+To run:
+
+```
+yarn run greeter
+```
 
 <p align="left">
   <img width="350" height="150" src= "../../assets/logo.svg" />

packages/greeter/README.md

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity >=0.6.11;
+pragma solidity ^0.8.0;
 
 contract Greeter {
     string greeting;

packages/greeter/contracts/Greeter.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "@arbitrum/nitro-contracts/src/precompiles/ArbSys.sol";
+import "@arbitrum/nitro-contracts/src/libraries/AddressAliasHelper.sol";
+import "../Greeter.sol";
+
+contract GreeterChild is Greeter {
+    ArbSys constant arbsys = ArbSys(address(100));
+    address public parentTarget;
+
+    event ChildToParentTxCreated(uint256 indexed withdrawalId);
+
+    constructor(string memory _greeting, address _parentTarget) Greeter(_greeting) {
+        parentTarget = _parentTarget;
+    }
+
+    function updateParentTarget(address _parentTarget) public {
+        parentTarget = _parentTarget;
+    }
+
+    function setGreetingInParent(string memory _greeting) public returns (uint256) {
+        bytes memory data = abi.encodeWithSelector(Greeter.setGreeting.selector, _greeting);
+
+        uint256 withdrawalId = arbsys.sendTxToL1(parentTarget, data);
+
+        emit ChildToParentTxCreated(withdrawalId);
+        return withdrawalId;
+    }
+
+    /// @notice only parentTarget can update greeting
+    function setGreeting(string memory _greeting) public override {
+        // To check that message came from the parent chain,
+        // we check that the sender is the parent chain contract's alias.
+        require(
+            msg.sender == AddressAliasHelper.applyL1ToL2Alias(parentTarget),
+            "Greeting only updateable by parent chain's address"
+        );
+        Greeter.setGreeting(_greeting);
+    }
+}