Implement feedback

Author: bradleycamacho

pages/stack/interop/deploy-superchain-erc20.mdx

@@ -13,7 +13,7 @@ import { Steps } from 'nextra/components'
   Interop is currently in active development and not yet ready for production use. The information provided here may change. Check back regularly for the most up-to-date information.
 </Callout>
 
-This guide explains how to issue new assets with the `SuperchainERC20` standard and bridge them effectively using the `SuperchainERC20Bridge`. If you want more information about the `SuperchainERC20 standard`, see our [`SuperchainERC20` standard explainer](/stack/interop/superchain-erc20)
+This guide explains how to issue new assets with the `SuperchainERC20` and bridge them effectively using the `SuperchainERC20Bridge`. If you want more information about the `SuperchainERC20 standard`, see our [`SuperchainERC20` standard explainer](/stack/interop/superchain-erc20)
 
 An important thing to note is using `crosschainBurn` and `crosschainMint` on the `SuperchainERC20` to move your asset across the Superchain only affects which chain your asset is located on and does not change the overall supply of the token. This keeps the token’s total amount the same across all networks, ensuring its value stays stable during the move and that the `SuperchainERC20` retains a unified, global supply count.
 
@@ -28,63 +28,21 @@ To ensure fungibility across chains, the SuperchainERC20 assets need to have the
 * `Create2Deployer`: A smart contract that enables deploying contracts with predictable addresses.
 * `OptimismSuperchainERC20Factory`: A factory contract designed for L1-native tokens to ensure uniform deployments across chains.
 
-There are [many ways to do this](https://github.com/Arachnid/deterministic-deployment-proxy), but here's an example smart contract to start:
-
-```solidity
-// Example token deployment using Create2Deployer
-bytes32 salt = keccak256(abi.encodePacked("SuperchainToken"));
-address tokenAddress = Create2Deployer.deploy(salt, bytecode, constructorArgs);
-```
+There are [many ways to do this](https://github.com/Arachnid/deterministic-deployment-proxy), but [here's an example smart contract to start](https://github.com/ethereum-optimism/superchainerc20-starter/blob/main/packages/contracts/src/L2NativeSuperchainERC20.sol)
 
 By deploying assets at identical addresses across multiple chains, we abstract away the complexity of cross-chain validation.
 
-### Implement the ICrosschainERC20 interface
-
-Ensure that your token contract conforms to the `ICrosschainERC20` interface to support cross-chain minting and burning. 
-
-```solidity
-interface ICrosschainERC20 {
-    function crosschainMint(address _account, uint256 _amount) external; /// Mints _amount of token to address _account.
-    function crosschainBurn(address _account, uint256 _amount) external; /// Burns _amount of token from address _account.
-
-    event CrosschainMint(address indexed _to, uint256 _amount); /// MUST trigger when crosschainMint is called
-    event CrosschainBurn(address indexed _from, uint256 _amount); /// MUST trigger when crosschainBurn is called
-}
-```
-
-### Use the `SuperchainERC20Bridge` for cross-chain transfers
+### Implement the IERC7802 interface
 
-The `SuperchainERC20Bridge` relies on the `L2ToL2CrossDomainMessenger` to securely relay messages between chains and provide replay protection, domain binding and access to additional message information.
+Implementations of `SuperchainERC2` will be required to implement the [IERC7802](https://specs.optimism.io/interop/token-bridging.html#ierc7802) interface, that includes two external functions and two events.
 
 We'll use two function for bridging:
 
 * `sendERC20`: initializes a cross-chain transfer of a `SuperchainERC20` by burning the tokens locally and sending a message to the `SuperchainERC20Bridge` on the target chain using the `L2toL2CrossDomainMessenger`. This ensures that asset supply never changes; sending an asset moves it from one chain to another, it does not "create" an additional asset in regards to supply.
 * `relayERC20`: process incoming messages from the L2toL2CrossDomainMessenger and mints the corresponding amount of the SuperchainERC20.
 
-Here's an example implementation of the `SuperchainERC20Bridge`
-
-```solidity
-function sendERC20(SuperchainERC20 _token, address _to, uint256 _amount, uint256 _chainId) external returns (bytes32 msgHash_) {
-  _token.crosschainBurn(msg.sender, _amount);
-
-  bytes memory _message = abi.encodeCall(this.relayERC20, (_token, msg.sender, _to, _amount));
-
-  msgHash_ = L2ToL2CrossDomainMessenger.sendMessage(_chainId, address(this), _message);
-  
-  emit SentERC20(address(_token), msg.sender, _to, _amount, _chainId);
-}
-
-function relayERC20(SuperchainERC20 _token, address _from, address _to, uint256 _amount) external {
-  require(msg.sender == address(L2ToL2CrossChainMessenger));
-  require(L2ToL2CrossChainMessenger.crossDomainMessageSender() == address(this));
-  
-  uint256 _source = L2ToL2CrossChainMessenger.crossDomainMessageSource();
-
-  _token.crosschainMint(_to, _amount);
+[Here's an example implementation of the `SuperchainERC20Bridge`](https://specs.optimism.io/interop/token-bridging.html#implementation)
 
-  emit RelayedERC20(address(_token), _from, _to, _amount, _source);
-}
-```
 </Steps>
 
 ## Next steps