Merge pull request #120 from OffchainLabs/add-contract-deposit

Add contract deposit

Author: Jason-W123

README.md

@@ -25,8 +25,9 @@ yarn install
 - ⤵️ 🔹 [Withdraw Ether](./packages/eth-withdraw/)
 - ⤴️ 💸 [Deposit Token](./packages/token-deposit/)
 - ⤵️ 💸 [Withdraw token](./packages/token-withdraw/)
+- ⤴️ 🔹 [L2 Alias Control and Fund Transfer Guide](./packages/contract-deposit/)
 
-#### :white_check_mark: General Interop
+#### :white_check_mark: General interop
 
 - 🤝 [Greeter](./packages/greeter/) (L1 to L2)
 - 📤 [Outbox](./packages/outbox-execute/) (L2 to L1)

packages/contract-deposit/.env-sample

@@ -0,0 +1,19 @@
+# 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. You can use any Arbitrum chain.
+
+L2RPC="https://sepolia-rollup.arbitrum.io/rpc"
+
+# Ethereum RPC; i.e., for Sepolia https://sepolia.infura.io/v3/<your infura key>
+
+L1RPC=""
+
+# The address that you will transfer the funds from your l2 alias to
+
+TransferTo=

packages/contract-deposit/.gitignore

@@ -0,0 +1,4 @@
+artifacts/
+cache/
+build/
+node_modules/

packages/contract-deposit/README.md

@@ -0,0 +1,34 @@
+# L2 alias control and fund transfer guide
+
+`L2 Alias Control and Fund Transfer Guide` is a simple demonstration of how Arbitrum facilitates sending deposits from an L1 contract to L2.
+
+It will deposit funds to l2 via a l1 contract, and because the inbox contract will alias the sender address if it is a contract,
+this tutorial shows how to control the alias address on l2 via its l1 contract address.
+
+This tutorial demonstrates depositing funds to L2 using an L1 contract. Since the Inbox contract changes the sender address if it's a contract [(a.k.a address aliasing)](https://docs.arbitrum.io/how-arbitrum-works/arbos/l1-l2-messaging#address-aliasing), it explains how to manage the new L2 address using the L1 contract address. It's a basic example of how an L1 contract controls its L2 alias and transfers its alias funds to another address. For practical use, we recommend our [funds recovery tool]((https://github.com/OffchainLabs/arbitrum-funds-recovery-tool)).
+
+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).
+
+See [./exec.js](./scripts/exec.js) for inline explanations.
+
+[Click here](https://developer.offchainlabs.com/docs/l1_l2_messages) for more info on retryable tickets.
+
+### Run demo:
+
+```
+yarn start
+```
+
+## Config environment variables
+
+Set the values shown in `.env-sample` as environmental variables. To copy it into a `.env` file:
+
+```shell
+cp .env-sample .env
+```
+
+(you'll still need to edit some variables, i.e., `DEVNET_PRIVKEY`)
+
+<p align="left">
+  <img width="350" height="150" src= "../../assets/logo.svg" />
+</p>

packages/contract-deposit/contracts/EthDeposit.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.6.11;
+
+import "@arbitrum/nitro-contracts/src/bridge/Inbox.sol";
+
+contract EthDeposit {
+    IInbox public inbox;
+
+    event EthDeposited(uint256 indexed ticketId);
+    event RetryableTicketCreated(uint256 indexed ticketId);
+
+    constructor(address _inbox) {
+        inbox = IInbox(_inbox);
+    }
+
+    function depositToL2() public payable returns (uint256) {
+        uint256 ticketID = inbox.depositEth{ value: msg.value }();
+
+        emit EthDeposited(ticketID);
+        return ticketID;
+    }
+
+    function moveFundsFromL2AliasToAnotherAddress(
+        address to,
+        uint256 l2callvalue,
+        uint256 maxSubmissionCost,
+        uint256 maxGas,
+        uint256 gasPriceBid
+    ) public payable returns (uint256) {
+        /**
+         * We are using unsafeCreateRetryableTicket because the safe one will check if
+         * the msg.value can be used to pay for the l2 callvalue while we will use l2's
+         * balance to pay for the l2 callvalue rather than l1 msg.value.
+         */
+        uint256 ticketID = inbox.unsafeCreateRetryableTicket{ value: msg.value }(
+            to,
+            l2callvalue,
+            maxSubmissionCost,
+            msg.sender,
+            msg.sender,
+            maxGas,
+            gasPriceBid,
+            ""
+        );
+        emit RetryableTicketCreated(ticketID);
+        return ticketID;
+    }
+}

packages/contract-deposit/hardhat.config.js

@@ -0,0 +1,4 @@
+require('@nomiclabs/hardhat-ethers')
+const { hardhatConfig } = require('arb-shared-dependencies')
+
+module.exports = hardhatConfig

packages/contract-deposit/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "contract-deposit",
+  "license": "Apache-2.0",
+  "version": "1.0.0",
+  "scripts": {
+    "build": "hardhat compile",
+    "start": "hardhat run scripts/exec.js"
+  },
+  "devDependencies": {
+    "@nomiclabs/hardhat-ethers": "^2.0.2",
+    "ethers": "^5.1.2",
+    "hardhat": "^2.2.0"
+  },
+  "dependencies": {
+    "@arbitrum/sdk": "^v3.1.9",
+    "@arbitrum/nitro-contracts": "v1.0.2",
+    "dotenv": "^8.2.0"
+  }
+}